Upload 9 files

bot.py

@@ -0,0 +1,204 @@
+import asyncio
+import logging
+import os
+import ssl
+import sys
+
+import aiohttp
+import certifi
+from aiohttp import web
+from aiogram import Bot, Dispatcher
+from aiogram.enums import ParseMode
+from aiogram.client.default import DefaultBotProperties
+from aiogram.webhook.aiohttp_server import SimpleRequestHandler, setup_application
+
+from config import config
+from database import db
+from handlers import commands_router, chat_router, callbacks_router
+from middlewares import OwnerMiddleware, RateLimitMiddleware
+
+
+# ═══════════════════════════════════════════════════════════════════
+# BLOCK 0: SSL-патчи для HF Spaces (certifi + proxy)
+# ═══════════════════════════════════════════════════════════════════
+custom_ssl = ssl.create_default_context(cafile=certifi.where())
+custom_ssl.check_hostname = True
+custom_ssl.verify_mode = ssl.CERT_REQUIRED
+
+_orig_tcp_init = aiohttp.TCPConnector.__init__
+
+
+def _patched_tcp_init(self, *args, **kwargs):
+    if kwargs.get("ssl") is not False:
+        kwargs["ssl"] = custom_ssl
+    _orig_tcp_init(self, *args, **kwargs)
+
+
+aiohttp.TCPConnector.__init__ = _patched_tcp_init
+
+_orig_session_init = aiohttp.ClientSession.__init__
+
+
+def _patched_session_init(self, *args, **kwargs):
+    kwargs["trust_env"] = True
+    _orig_session_init(self, *args, **kwargs)
+
+
+aiohttp.ClientSession.__init__ = _patched_session_init
+
+_orig_request = aiohttp.ClientSession._request
+
+
+async def _patched_request(self, method, url, *args, **kwargs):
+    proxy_server = os.getenv("TELEGRAM_API_SERVER")
+    if proxy_server and "api.telegram.org" in str(url):
+        proxy_server = proxy_server.strip().rstrip("/")
+        str_url = str(url).replace("https://api.telegram.org", proxy_server)
+        logging.info("🔀 Переадресация aiogram через прокси ➡️ %s", str_url)
+        url = str_url
+    return await _orig_request(self, method, url, *args, **kwargs)
+
+
+aiohttp.ClientSession._request = _patched_request
+
+
+# ═══════════════════════════════════════════════════════════════════
+# BLOCK 1: Логирование
+# ═══════════════════════════════════════════════════════════════════
+def setup_logging() -> None:
+    level = getattr(logging, config.LOG_LEVEL.upper(), logging.INFO)
+    logging.basicConfig(
+        level=level,
+        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+        stream=sys.stdout,
+    )
+    # Уменьшаем шум от библиотек
+    logging.getLogger("httpx").setLevel(logging.WARNING)
+    logging.getLogger("httpcore").setLevel(logging.WARNING)
+    logging.getLogger("aiogram").setLevel(logging.INFO)
+
+
+# ═══════════════════════════════════════════════════════════════════
+# BLOCK 2: Инициализация бота и диспетчера
+# ═══════════════════════════════════════════════════════════════════
+bot = Bot(
+    token=config.BOT_TOKEN,
+    default=DefaultBotProperties(parse_mode=ParseMode.HTML)
+)
+dp = Dispatcher()
+
+# Middlewares (порядок важен!)
+dp.message.middleware(OwnerMiddleware())
+dp.message.middleware(RateLimitMiddleware())
+
+# Logging middleware
+@dp.update.middleware()
+async def log_updates(handler, event, data):
+    logger = logging.getLogger(__name__)
+    logger.info("→ Update received: %s", event.update_id if hasattr(event, 'update_id') else 'N/A')
+    try:
+        return await handler(event, data)
+    except Exception as e:
+        logger.error("Update failed: %s", e, exc_info=True)
+        raise
+
+# Routers (порядок важен: commands → callbacks → chat)
+dp.include_router(commands_router)
+dp.include_router(callbacks_router)
+dp.include_router(chat_router)
+
+
+# ═══════════════════════════════════════════════════════════════════
+# BLOCK 3: HTTP Handlers
+# ═══════════════════════════════════════════════════════════════════
+@web.middleware
+async def hf_logging_middleware(request, handler):
+    return await handler(request)
+
+
+async def health_check(request: web.Request) -> web.Response:
+    """HF Spaces Health Check — обязательно отвечать 200 на '/'."""
+    return web.Response(text="🚀 GLM Bot РАБОТАЕТ!")
+
+
+# ═══════════════════════════════════════════════════════════════════
+# BLOCK 4: Lifecycle hooks
+# ═══════════════════════════════════════════════════════════════════
+async def on_startup(app: web.Application) -> None:
+    logger = logging.getLogger(__name__)
+    await db.connect()
+    logger.info("✅ Database connected")
+
+    space_host = os.getenv("SPACE_HOST", "")
+    if space_host:
+        full_webhook_link = f"https://{space_host.strip()}{config.WEBHOOK_PATH}"
+        for attempt in range(5):
+            try:
+                await bot.set_webhook(
+                    url=full_webhook_link,
+                    drop_pending_updates=True,
+                    request_timeout=30,
+                )
+                logger.info("✅ Webhook установлен: %s", full_webhook_link)
+                break
+            except Exception as e:
+                logger.warning(
+                    "⚠️ Попытка %d/5 установки webhook: %s", attempt + 1, e
+                )
+                await asyncio.sleep(5)
+    else:
+        logger.warning("⚠️ SPACE_HOST не задан, webhook не установлен!")
+
+
+async def on_shutdown(app: web.Application) -> None:
+    logger = logging.getLogger(__name__)
+    logger.info("🛑 Shutdown начат...")
+
+    try:
+        await bot.delete_webhook(drop_pending_updates=True)
+        logger.info("Webhook удалён")
+    except Exception as e:
+        logger.warning("Ошибка при удалении webhook: %s", e)
+
+    try:
+        await dp.storage.close()
+        await bot.session.close()
+        logger.info("Bot session закрыт")
+    except Exception as e:
+        logger.warning("Ошибка при закрытии сессии бота: %s", e)
+
+    try:
+        await db.disconnect()
+        logger.info("Database disconnected")
+    except Exception as e:
+        logger.warning("Ошибка при отключении БД: %s", e)
+
+
+# ═══════════════════════════════════════════════════════════════════
+# BLOCK 5: Main
+# ═══════════════════════════════════════════════════════════════════
+def main() -> None:
+    setup_logging()
+    logger = logging.getLogger(__name__)
+    logger.info("🚀 Starting HF Spaces bot...")
+    logger.info("Config: model=%s, fallback=%s, streaming=%s, rate_limit=%s",
+                config.PRIMARY_MODEL, config.FALLBACK_MODEL,
+                config.STREAMING_ENABLED, config.RATE_LIMIT_ENABLED)
+
+    app = web.Application(middlewares=[hf_logging_middleware])
+    app.router.add_get("/", health_check)
+
+    webhook_requests_handler = SimpleRequestHandler(dispatcher=dp, bot=bot)
+    webhook_requests_handler.register(app, path=config.WEBHOOK_PATH)
+    setup_application(app, dp, bot=bot)
+
+    app.on_startup.append(on_startup)
+    app.on_shutdown.append(on_shutdown)
+
+    port = int(os.environ.get("PORT", 7860))
+    logger.info("🚀 Запуск сервера на %s:%d...", "0.0.0.0", port)
+    web.run_app(app, host="0.0.0.0", port=port)
+
+
+if __name__ == "__main__":
+    main()

config.py

@@ -0,0 +1,129 @@
+import os
+from dataclasses import dataclass, field
+from dotenv import load_dotenv
+
+load_dotenv()
+
+
+@dataclass
+class Config:
+    # ═══════════════════════════════════════════════════════════════
+    # BLOCK: Telegram
+    # ═══════════════════════════════════════════════════════════════
+    BOT_TOKEN: str = os.getenv("BOT_TOKEN", "")
+    OWNER_ID: int = int(os.getenv("OWNER_ID", "0") or "0")
+    WEBHOOK_PATH: str = "/webhook"
+
+    # ═══════════════════════════════════════════════════════════════
+    # BLOCK: Database (Neon PostgreSQL)
+    # ═══════════════════════════════════════════════════════════════
+    DATABASE_URL: str = os.getenv("DATABASE_URL", "")
+
+    # ═══════════════════════════════════════════════════════════════
+    # BLOCK: AI — Primary Model (GLM-4.5 via NVIDIA)
+    # ═══════════════════════════════════════════════════════════════
+    NVIDIA_API_KEY: str = os.getenv("NVIDIA_API_KEY", "")
+    NVIDIA_BASE_URL: str = "https://integrate.api.nvidia.com/v1"
+    PRIMARY_MODEL: str = "z-ai/glm-4.5"  # или "z-ai/glm-5.1" — обнови под свою модель
+
+    # ═══════════════════════════════════════════════════════════════
+    # BLOCK: AI — Fallback Model
+    # ═══════════════════════════════════════════════════════════════
+    FALLBACK_MODEL: str = os.getenv("FALLBACK_MODEL", "meta/llama-3.3-70b-instruct")
+    FALLBACK_ENABLED: bool = os.getenv("FALLBACK_ENABLED", "true").lower() == "true"
+
+    # ═══════════════════════════════════════════════════════════════
+    # BLOCK: AI Parameters — Optimized for GLM-4.5
+    # ═══════════════════════════════════════════════════════════════
+    # GLM-4.5 рекомендации через NVIDIA NIM:
+    # - temperature: 0.3–0.8 (ниже = точнее, выше = креативнее)
+    # - top_p: 0.7–0.95
+    # - max_tokens: зависит от задачи, 4096–8192 для длинных ответов
+    GLM_TEMPERATURE: float = float(os.getenv("GLM_TEMPERATURE", "0.7"))
+    GLM_TOP_P: float = float(os.getenv("GLM_TOP_P", "0.9"))
+    GLM_FREQUENCY_PENALTY: float = float(os.getenv("GLM_FREQUENCY_PENALTY", "0.1"))
+    GLM_PRESENCE_PENALTY: float = float(os.getenv("GLM_PRESENCE_PENALTY", "0.05"))
+    GLM_MAX_TOKENS: int = int(os.getenv("GLM_MAX_TOKENS", "4096"))
+
+    # ═══════════════════════════════════════════════════════════════
+    # BLOCK: Timeouts — Granular for NVIDIA NIM
+    # ═══════════════════════════════════════════════════════════════
+    # NVIDIA NIM может отвечать 2–3 минуты на сложные запросы.
+    # connect: время установления TCP-соединения
+    # read: время ожидания первого байта ответа
+    # write: время на отправку запроса
+    TIMEOUT_CONNECT: float = float(os.getenv("TIMEOUT_CONNECT", "10.0"))
+    TIMEOUT_READ: float = float(os.getenv("TIMEOUT_READ", "180.0"))      # 3 минуты
+    TIMEOUT_WRITE: float = float(os.getenv("TIMEOUT_WRITE", "10.0"))
+    TIMEOUT_POOL: float = float(os.getenv("TIMEOUT_POOL", "5.0"))
+
+    # ═══════════════════════════════════════════════════════════════
+    # BLOCK: Retry Configuration
+    # ═══════════════════════════════════════════════════════════════
+    MAX_RETRIES: int = int(os.getenv("MAX_RETRIES", "3"))
+    RETRY_BASE_DELAY: float = float(os.getenv("RETRY_BASE_DELAY", "2.0"))
+    RETRY_MAX_DELAY: float = float(os.getenv("RETRY_MAX_DELAY", "60.0"))
+    RETRY_EXPONENTIAL_BASE: float = float(os.getenv("RETRY_EXPONENTIAL_BASE", "2.0"))
+
+    # ═══════════════════════════════════════════════════════════════
+    # BLOCK: Streaming
+    # ═══════════════════════════════════════════════════════════════
+    STREAMING_ENABLED: bool = os.getenv("STREAMING_ENABLED", "true").lower() == "true"
+    STREAMING_CHUNK_SIZE: int = int(os.getenv("STREAMING_CHUNK_SIZE", "100"))
+    STREAMING_UPDATE_INTERVAL: float = float(os.getenv("STREAMING_UPDATE_INTERVAL", "1.5"))
+
+    # ═══════════════════════════════════════════════════════════════
+    # BLOCK: History & Memory
+    # ═══════════════════════════════════════════════════════════════
+    MAX_HISTORY: int = int(os.getenv("MAX_HISTORY", "20"))           # сообщений в контексте
+    MAX_CONTEXT_TOKENS: int = int(os.getenv("MAX_CONTEXT_TOKENS", "6000"))  # примерно токенов
+    SUMMARIZE_THRESHOLD: int = int(os.getenv("SUMMARIZE_THRESHOLD", "30"))
+    SUMMARY_MAX_TOKENS: int = int(os.getenv("SUMMARY_MAX_TOKENS", "512"))
+    KEEP_RECENT_MESSAGES: int = int(os.getenv("KEEP_RECENT_MESSAGES", "10"))
+
+    # ═══════════════════════════════════════════════════════════════
+    # BLOCK: Telegram Limits
+    # ═══════════════════════════════════════════════════════════════
+    MAX_MESSAGE_LENGTH: int = 4096
+    TYPING_ACTION_INTERVAL: float = 4.5  # Telegram typing action expires after ~5s
+
+    # ═══════════════════════════════════════════════════════════════
+    # BLOCK: Rate Limiting
+    # ═══════════════════════════════════════════════════════════════
+    RATE_LIMIT_ENABLED: bool = os.getenv("RATE_LIMIT_ENABLED", "true").lower() == "true"
+    RATE_LIMIT_REQUESTS_PER_MINUTE: int = int(os.getenv("RATE_LIMIT_REQUESTS_PER_MINUTE", "10"))
+    RATE_LIMIT_BURST: int = int(os.getenv("RATE_LIMIT_BURST", "3"))
+
+    # ═══════════════════════════════════════════════════════════════
+    # BLOCK: Cache
+    # ═══════════════════════════════════════════════════════════════
+    CACHE_ENABLED: bool = os.getenv("CACHE_ENABLED", "true").lower() == "true"
+    CACHE_TTL_SECONDS: int = int(os.getenv("CACHE_TTL_SECONDS", "300"))  # 5 минут
+    CACHE_MAX_SIZE: int = int(os.getenv("CACHE_MAX_SIZE", "1000"))
+
+    # ═══════════════════════════════════════════════════════════════
+    # BLOCK: Monitoring
+    # ═══════════════════════════════════════════════════════════════
+    LOG_LEVEL: str = os.getenv("LOG_LEVEL", "INFO")
+    METRICS_ENABLED: bool = os.getenv("METRICS_ENABLED", "true").lower() == "true"
+
+    def __post_init__(self) -> None:
+        if self.DATABASE_URL.startswith("postgres://"):
+            self.DATABASE_URL = self.DATABASE_URL.replace(
+                "postgres://", "postgresql://", 1
+            )
+
+    def validate(self) -> None:
+        required = [
+            ("BOT_TOKEN", self.BOT_TOKEN),
+            ("OWNER_ID", self.OWNER_ID),
+            ("DATABASE_URL", self.DATABASE_URL),
+            ("NVIDIA_API_KEY", self.NVIDIA_API_KEY),
+        ]
+        for name, value in required:
+            if not value:
+                raise ValueError(f"{name} is required")
+
+
+config = Config()
+config.validate()

database.py

@@ -0,0 +1,403 @@
+import asyncpg
+import logging
+import time
+from typing import Optional, List, Dict, Any
+from config import config
+
+logger = logging.getLogger(__name__)
+
+
+class Database:
+    def __init__(self) -> None:
+        self.pool: Optional[asyncpg.Pool] = None
+
+    async def connect(self) -> None:
+        self.pool = await asyncpg.create_pool(
+            dsn=config.DATABASE_URL,
+            min_size=1,
+            max_size=5,  # увеличено для масштабируемости
+            command_timeout=60,
+            server_settings={
+                "jit": "off",  # отключаем JIT для стабильности
+                "application_name": "glm_bot",
+            },
+        )
+        logger.info("Database pool created (max_size=5)")
+        await self._create_tables()
+        await self._create_indexes()
+
+    async def disconnect(self) -> None:
+        if self.pool:
+            await self.pool.close()
+            logger.info("Database pool closed")
+
+    def _acquire(self):
+        if self.pool is None:
+            raise RuntimeError("Database not connected. Call connect() first.")
+        return self.pool.acquire()
+
+    async def _create_tables(self) -> None:
+        async with self._acquire() as conn:
+            # Users table
+            await conn.execute("""
+                CREATE TABLE IF NOT EXISTS users (
+                    id BIGINT PRIMARY KEY,
+                    username VARCHAR(255),
+                    first_name VARCHAR(255),
+                    last_name VARCHAR(255),
+                    created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+                    updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+                    settings JSONB DEFAULT '{}'::jsonb
+                )
+            """)
+
+            # Messages table
+            await conn.execute("""
+                CREATE TABLE IF NOT EXISTS messages (
+                    id SERIAL PRIMARY KEY,
+                    user_id BIGINT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+                    role VARCHAR(20) NOT NULL CHECK (role IN ('user', 'assistant', 'system')),
+                    content TEXT NOT NULL,
+                    tokens_used INTEGER DEFAULT 0,
+                    is_summarized BOOLEAN DEFAULT FALSE,
+                    created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+                )
+            """)
+
+            # Summaries table
+            await conn.execute("""
+                CREATE TABLE IF NOT EXISTS summaries (
+                    id SERIAL PRIMARY KEY,
+                    user_id BIGINT NOT NULL UNIQUE REFERENCES users(id) ON DELETE CASCADE,
+                    summary TEXT NOT NULL,
+                    message_count INTEGER NOT NULL DEFAULT 0,
+                    created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+                    updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+                )
+            """)
+
+            # Metrics table — для мониторинга
+            await conn.execute("""
+                CREATE TABLE IF NOT EXISTS metrics (
+                    id SERIAL PRIMARY KEY,
+                    user_id BIGINT REFERENCES users(id) ON DELETE SET NULL,
+                    model VARCHAR(100),
+                    request_duration_ms FLOAT,
+                    tokens_input INTEGER DEFAULT 0,
+                    tokens_output INTEGER DEFAULT 0,
+                    total_tokens INTEGER DEFAULT 0,
+                    success BOOLEAN DEFAULT TRUE,
+                    error_type VARCHAR(100),
+                    created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+                )
+            """)
+
+            # Rate limiting table
+            await conn.execute("""
+                CREATE TABLE IF NOT EXISTS rate_limits (
+                    user_id BIGINT PRIMARY KEY REFERENCES users(id) ON DELETE CASCADE,
+                    request_count INTEGER DEFAULT 0,
+                    window_start TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+                    updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+                )
+            """)
+
+            logger.info("Database tables created/verified")
+
+    async def _create_indexes(self) -> None:
+        async with self._acquire() as conn:
+            await conn.execute("""
+                CREATE INDEX IF NOT EXISTS idx_messages_user_id_created_at
+                ON messages(user_id, created_at DESC)
+            """)
+            await conn.execute("""
+                CREATE INDEX IF NOT EXISTS idx_messages_user_id_summarized
+                ON messages(user_id, is_summarized, created_at DESC)
+            """)
+            await conn.execute("""
+                CREATE INDEX IF NOT EXISTS idx_metrics_user_created
+                ON metrics(user_id, created_at DESC)
+            """)
+            await conn.execute("""
+                CREATE INDEX IF NOT EXISTS idx_metrics_created_at
+                ON metrics(created_at DESC)
+            """)
+
+    # ═══════════════════════════════════════════════════════════════
+    # Users
+    # ═══════════════════════════════════════════════════════════════
+    async def upsert_user(
+        self,
+        user_id: int,
+        username: Optional[str],
+        first_name: Optional[str],
+        last_name: Optional[str],
+    ) -> None:
+        async with self._acquire() as conn:
+            await conn.execute("""
+                INSERT INTO users (id, username, first_name, last_name)
+                VALUES ($1, $2, $3, $4)
+                ON CONFLICT (id) DO UPDATE SET
+                    username = EXCLUDED.username,
+                    first_name = EXCLUDED.first_name,
+                    last_name = EXCLUDED.last_name,
+                    updated_at = NOW()
+            """, user_id, username, first_name, last_name)
+
+    async def get_user_settings(self, user_id: int) -> Dict[str, Any]:
+        async with self._acquire() as conn:
+            row = await conn.fetchrow("""
+                SELECT settings FROM users WHERE id = $1
+            """, user_id)
+            return row["settings"] if row and row["settings"] else {}
+
+    async def update_user_settings(self, user_id: int, settings: Dict[str, Any]) -> None:
+        async with self._acquire() as conn:
+            await conn.execute("""
+                UPDATE users SET settings = $2, updated_at = NOW() WHERE id = $1
+            """, user_id, settings)
+
+    # ═══════════════════════════════════════════════════════════════
+    # Messages
+    # ═══════════════════════════════════════════════════════════════
+    async def save_message(
+        self, user_id: int, role: str, content: str, tokens_used: int = 0
+    ) -> None:
+        async with self._acquire() as conn:
+            await conn.execute("""
+                INSERT INTO messages (user_id, role, content, tokens_used)
+                VALUES ($1, $2, $3, $4)
+            """, user_id, role, content, tokens_used)
+
+    async def get_messages(self, user_id: int, limit: int = 30) -> List[Dict[str, Any]]:
+        async with self._acquire() as conn:
+            rows = await conn.fetch("""
+                SELECT id, role, content, tokens_used, created_at
+                FROM messages
+                WHERE user_id = $1 AND is_summarized = FALSE
+                ORDER BY created_at DESC
+                LIMIT $2
+            """, user_id, limit)
+            return [
+                {
+                    "id": r["id"],
+                    "role": r["role"],
+                    "content": r["content"],
+                    "tokens_used": r["tokens_used"],
+                    "created_at": r["created_at"],
+                }
+                for r in reversed(rows)
+            ]
+
+    async def get_messages_with_token_budget(
+        self, user_id: int, max_tokens: int
+    ) -> List[Dict[str, Any]]:
+        """Возвращает сообщения, укладывающиеся в бюджет токенов."""
+        async with self._acquire() as conn:
+            rows = await conn.fetch("""
+                SELECT id, role, content, tokens_used, created_at
+                FROM messages
+                WHERE user_id = $1 AND is_summarized = FALSE
+                ORDER BY created_at DESC
+            """, user_id)
+
+            result = []
+            total_tokens = 0
+            for r in rows:
+                msg_tokens = r["tokens_used"] or len(r["content"].split()) * 2
+                if total_tokens + msg_tokens > max_tokens and result:
+                    break
+                total_tokens += msg_tokens
+                result.insert(0, {
+                    "id": r["id"],
+                    "role": r["role"],
+                    "content": r["content"],
+                    "tokens_used": r["tokens_used"],
+                    "created_at": r["created_at"],
+                })
+            return result
+
+    # ═══════════════════════════════════════════════════════════════
+    # Summaries
+    # ═══════════════════════════════════════════════════════════════
+    async def get_summary(self, user_id: int) -> Optional[str]:
+        async with self._acquire() as conn:
+            row = await conn.fetchrow("""
+                SELECT summary FROM summaries WHERE user_id = $1
+            """, user_id)
+            return row["summary"] if row else None
+
+    async def save_summary(self, user_id: int, summary: str, message_count: int) -> None:
+        async with self._acquire() as conn:
+            await conn.execute("""
+                INSERT INTO summaries (user_id, summary, message_count, updated_at)
+                VALUES ($1, $2, $3, NOW())
+                ON CONFLICT (user_id) DO UPDATE SET
+                    summary = EXCLUDED.summary,
+                    message_count = summaries.message_count + EXCLUDED.message_count,
+                    updated_at = NOW()
+            """, user_id, summary, message_count)
+
+    async def mark_summarized(self, user_id: int, cutoff_id: int) -> None:
+        async with self._acquire() as conn:
+            await conn.execute("""
+                UPDATE messages
+                SET is_summarized = TRUE
+                WHERE user_id = $1 AND id <= $2
+            """, user_id, cutoff_id)
+
+    async def get_oldest_unsummarized(self, user_id: int, limit: int) -> List[Dict[str, Any]]:
+        async with self._acquire() as conn:
+            rows = await conn.fetch("""
+                SELECT id, role, content
+                FROM messages
+                WHERE user_id = $1 AND is_summarized = FALSE
+                ORDER BY created_at ASC
+                LIMIT $2
+            """, user_id, limit)
+            return [{"id": r["id"], "role": r["role"], "content": r["content"]} for r in rows]
+
+    async def count_unsummarized(self, user_id: int) -> int:
+        async with self._acquire() as conn:
+            val = await conn.fetchval("""
+                SELECT COUNT(*) FROM messages
+                WHERE user_id = $1 AND is_summarized = FALSE
+            """, user_id)
+            return val or 0
+
+    # ═══════════════════════════════════════════════════════════════
+    # Clear History
+    # ═══════════════════════════════════════════════════════════════
+    async def clear_history(self, user_id: int) -> int:
+        async with self._acquire() as conn:
+            async with conn.transaction():
+                result = await conn.execute("""
+                    DELETE FROM messages WHERE user_id = $1
+                """, user_id)
+                await conn.execute("""
+                    DELETE FROM summaries WHERE user_id = $1
+                """, user_id)
+                try:
+                    count = int(result.split()[-1])
+                except (ValueError, IndexError):
+                    count = 0
+                logger.info("Cleared %d messages and summary for user %s", count, user_id)
+                return count
+
+    # ═══════════════════════════════════════════════════════════════
+    # Stats
+    # ═══════════════════════════════════════════════════════════════
+    async def get_stats(self, user_id: int) -> Dict[str, Any]:
+        async with self._acquire() as conn:
+            user_count = await conn.fetchval("SELECT COUNT(*) FROM users")
+            msg_count = await conn.fetchval(
+                "SELECT COUNT(*) FROM messages WHERE user_id = $1", user_id
+            )
+            total_msg_count = await conn.fetchval("SELECT COUNT(*) FROM messages")
+            summary = await conn.fetchval(
+                "SELECT message_count FROM summaries WHERE user_id = $1", user_id
+            )
+            total_tokens = await conn.fetchval("""
+                SELECT COALESCE(SUM(total_tokens), 0) FROM metrics WHERE user_id = $1
+            """, user_id)
+            avg_latency = await conn.fetchval("""
+                SELECT COALESCE(AVG(request_duration_ms), 0)
+                FROM metrics WHERE user_id = $1 AND success = TRUE
+            """, user_id)
+            return {
+                "total_users": user_count,
+                "user_messages": msg_count,
+                "total_messages": total_msg_count,
+                "summarized_messages": summary or 0,
+                "total_tokens_used": int(total_tokens),
+                "avg_latency_ms": round(avg_latency, 1) if avg_latency else 0,
+            }
+
+    # ═══════════════════════════════════════════════════════════════
+    # Metrics
+    # ═══════════════════════════════════════════════════════════════
+    async def save_metric(
+        self,
+        user_id: Optional[int],
+        model: str,
+        duration_ms: float,
+        tokens_input: int = 0,
+        tokens_output: int = 0,
+        success: bool = True,
+        error_type: Optional[str] = None,
+    ) -> None:
+        async with self._acquire() as conn:
+            await conn.execute("""
+                INSERT INTO metrics
+                (user_id, model, request_duration_ms, tokens_input, tokens_output,
+                 total_tokens, success, error_type)
+                VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
+            """, user_id, model, duration_ms, tokens_input, tokens_output,
+                tokens_input + tokens_output, success, error_type)
+
+    async def get_user_metrics(self, user_id: int, limit: int = 50) -> List[Dict[str, Any]]:
+        async with self._acquire() as conn:
+            rows = await conn.fetch("""
+                SELECT model, request_duration_ms, total_tokens, success, error_type, created_at
+                FROM metrics WHERE user_id = $1 ORDER BY created_at DESC LIMIT $2
+            """, user_id, limit)
+            return [dict(r) for r in rows]
+
+    # ═══════════════════════════════════════════════════════════════
+    # Rate Limiting
+    # ═══════════════════════════════════════════════════════════════
+    async def check_rate_limit(self, user_id: int) -> tuple[bool, int, float]:
+        """Returns (allowed, remaining_requests, reset_in_seconds)."""
+        if not config.RATE_LIMIT_ENABLED:
+            return True, 999, 0.0
+
+        async with self._acquire() as conn:
+            async with conn.transaction():
+                row = await conn.fetchrow("""
+                    SELECT request_count, window_start
+                    FROM rate_limits WHERE user_id = $1
+                    FOR UPDATE
+                """, user_id)
+
+                now = time.time()
+                window_duration = 60  # 1 minute
+
+                if not row:
+                    await conn.execute("""
+                        INSERT INTO rate_limits (user_id, request_count, window_start)
+                        VALUES ($1, 1, NOW())
+                    """, user_id)
+                    return True, config.RATE_LIMIT_REQUESTS_PER_MINUTE - 1, window_duration
+
+                window_start_ts = row["window_start"].timestamp()
+                if now - window_start_ts >= window_duration:
+                    # Window expired, reset
+                    await conn.execute("""
+                        UPDATE rate_limits
+                        SET request_count = 1, window_start = NOW(), updated_at = NOW()
+                        WHERE user_id = $1
+                    """, user_id)
+                    return True, config.RATE_LIMIT_REQUESTS_PER_MINUTE - 1, window_duration
+
+                if row["request_count"] >= config.RATE_LIMIT_REQUESTS_PER_MINUTE:
+                    reset_in = window_duration - (now - window_start_ts)
+                    return False, 0, reset_in
+
+                await conn.execute("""
+                    UPDATE rate_limits
+                    SET request_count = request_count + 1, updated_at = NOW()
+                    WHERE user_id = $1
+                """, user_id)
+
+                remaining = config.RATE_LIMIT_REQUESTS_PER_MINUTE - row["request_count"] - 1
+                reset_in = window_duration - (now - window_start_ts)
+                return True, remaining, reset_in
+
+    async def reset_rate_limit(self, user_id: int) -> None:
+        async with self._acquire() as conn:
+            await conn.execute("""
+                DELETE FROM rate_limits WHERE user_id = $1
+            """, user_id)
+
+
+db = Database()

handlers callbacks.py

@@ -0,0 +1,82 @@
+import logging
+from aiogram import Router, types, F
+from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
+from database import db
+from handlers.commands import get_main_menu
+
+logger = logging.getLogger(__name__)
+router = Router()
+
+
+@router.callback_query(F.data == "regenerate")
+async def cb_regenerate(callback: types.CallbackQuery) -> None:
+    """Помечает последнее сообщение пользователя для регенерации."""
+    await callback.answer("🔄 Регенерация...")
+    # Удаляем последний ответ ассистента, чтобы chat handler перегенерировал
+    user_id = callback.from_user.id
+    # Получаем последнее сообщение пользователя
+    history = await db.get_messages(user_id, limit=2)
+    if len(history) >= 1 and history[-1]["role"] == "user":
+        await callback.message.answer(
+            "🔄 <b>Регенерирую ответ...</b>",
+            parse_mode="HTML",
+        )
+    else:
+        await callback.message.answer(
+            "❌ Нет сообщения для регенерации.",
+            parse_mode="HTML",
+        )
+
+
+@router.callback_query(F.data == "clear_memory")
+async def cb_clear_memory(callback: types.CallbackQuery) -> None:
+    user_id = callback.from_user.id
+    count = await db.clear_history(user_id)
+    await callback.answer("🗑 Память очищена!")
+    await callback.message.answer(
+        f"🗑 <b>Память очищена.</b>\nУдалено сообщений: <code>{count}</code>.",
+        parse_mode="HTML",
+        reply_markup=get_main_menu(),
+    )
+
+
+@router.callback_query(F.data == "show_stats")
+async def cb_show_stats(callback: types.CallbackQuery) -> None:
+    stats = await db.get_stats(callback.from_user.id)
+    await callback.answer()
+    await callback.message.answer(
+        f"📊 <b>Статистика:</b>\n\n"
+        f"💬 Ваших сообщений: <code>{stats['user_messages']}</code>\n"
+        f"📝 Суммаризировано: <code>{stats['summarized_messages']}</code>\n"
+        f"🔢 Токенов: <code>{stats['total_tokens_used']}</code>\n"
+        f"⏱ Средняя задержка: <code>{stats['avg_latency_ms']} мс</code>",
+        parse_mode="HTML",
+    )
+
+
+@router.callback_query(F.data == "show_settings")
+async def cb_show_settings(callback: types.CallbackQuery) -> None:
+    from config import config
+    await callback.answer()
+    kb = InlineKeyboardMarkup(inline_keyboard=[
+        [InlineKeyboardButton(text="🌡 Temperature", callback_data="set_temp")],
+        [InlineKeyboardButton(text="📏 Max Tokens", callback_data="set_max_tokens")],
+        [InlineKeyboardButton(text="🔙 Назад", callback_data="back_to_menu")],
+    ])
+    await callback.message.answer(
+        "⚙️ <b>Настройки:</b>\n\n"
+        f"🌡 Temperature: <code>{config.GLM_TEMPERATURE}</code>\n"
+        f"📏 Max Tokens: <code>{config.GLM_MAX_TOKENS}</code>\n"
+        f"🔄 Streaming: <code>{'ON' if config.STREAMING_ENABLED else 'OFF'}</code>",
+        parse_mode="HTML",
+        reply_markup=kb,
+    )
+
+
+@router.callback_query(F.data == "back_to_menu")
+async def cb_back_to_menu(callback: types.CallbackQuery) -> None:
+    await callback.answer()
+    await callback.message.answer(
+        "👋 Главное меню:",
+        reply_markup=get_main_menu(),
+    )

handlers chat.py

@@ -0,0 +1,261 @@
+import asyncio
+import logging
+import time
+from aiogram import Router, types, F
+from aiogram.exceptions import TelegramAPIError
+from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
+from aiogram.enums import ParseMode
+
+from config import config
+from database import db
+from services.glm import glm_service, LLMServiceError
+from utils.helpers import send_long_message, edit_or_send_message
+
+logger = logging.getLogger(__name__)
+router = Router()
+
+# In-memory cache for last user messages (for regeneration)
+_last_user_messages: dict[int, str] = {}
+
+SYSTEM_PROMPT = {
+    "role": "system",
+    "content": (
+        "Ты — AI-ассистент на базе GLM-4.5, работающий через NVIDIA NIM API. "
+        "Ты помогаешь пользователю как Senior Staff Python Engineer и Acting CTO.\n\n"
+        "Правила работы:\n"
+        "1. Отвечай на русском языке, если не указано иное.\n"
+        "2. Код пиши production-ready, Python 3.11+, async-safe.\n"
+        "3. Используй PATCH MODE для изменений >200 строк.\n"
+        "4. Не ломай существующую архитектуру.\n"
+        "5. Минимальные изменения — локальные патчи.\n"
+        "6. Не используй TODO, FIXME, PLACEHOLDER, PASS.\n"
+        "7. Проверяй безопасность: SQL Injection, Race Conditions, Async Safety.\n"
+        "8. Если не хватает контекста — запроси дополнительный код.\n"
+        "9. Не придумывай существующие методы/классы/API.\n"
+        "10. Перед кодом: анализ, архитектура, точка интеграции, зависимости."
+    ),
+}
+
+
+def get_chat_buttons() -> InlineKeyboardMarkup:
+    """Кнопки под ответом бота."""
+    return InlineKeyboardMarkup(inline_keyboard=[
+        [
+            InlineKeyboardButton(text="🔄 Регенерировать", callback_data="regenerate"),
+            InlineKeyboardButton(text="🗑 Очистить", callback_data="clear_memory"),
+        ],
+    ])
+
+
+async def _keep_typing(message: types.Message, stop_event: asyncio.Event) -> None:
+    """Периодически отправляет typing action, пока stop_event не установлен."""
+    while not stop_event.is_set():
+        try:
+            await message.bot.send_chat_action(message.chat.id, "typing")
+        except TelegramAPIError as e:
+            logger.debug("Typing action failed: %s", e)
+        try:
+            await asyncio.wait_for(stop_event.wait(), timeout=config.TYPING_ACTION_INTERVAL)
+        except asyncio.TimeoutError:
+            continue
+
+
+async def _maybe_summarize(user_id: int) -> None:
+    """Фоновая суммаризация старой истории."""
+    try:
+        count = await db.count_unsummarized(user_id)
+        threshold = config.SUMMARIZE_THRESHOLD
+        keep_recent = config.KEEP_RECENT_MESSAGES
+
+        if count <= threshold:
+            return
+
+        to_summarize = count - keep_recent
+        if to_summarize < 5:
+            return
+
+        old_messages = await db.get_oldest_unsummarized(user_id, to_summarize)
+        if len(old_messages) < 5:
+            return
+
+        dialog_text = "\n".join([
+            f"{m['role']}: {m['content']}" for m in old_messages
+        ])
+
+        summary = await glm_service.summarize(dialog_text)
+        if not summary:
+            return
+
+        cutoff_id = old_messages[-1]["id"]
+        await db.save_summary(user_id, summary, len(old_messages))
+        await db.mark_summarized(user_id, cutoff_id)
+
+        logger.info(
+            "Summarized %d messages for user %s, cutoff_id=%s",
+            len(old_messages), user_id, cutoff_id
+        )
+    except Exception as e:
+        logger.error("Summarization failed for user %s: %s", user_id, e, exc_info=True)
+
+
+async def _build_messages(user_id: int, user_text: str) -> list[dict]:
+    """Строит список сообщений для LLM с учётом бюджета токенов."""
+    messages: list[dict] = [SYSTEM_PROMPT]
+
+    # Добавляем summary как контекст
+    summary = await db.get_summary(user_id)
+    if summary:
+        messages.append({
+            "role": "system",
+            "content": f"[Контекст предыдущих диалогов: {summary}]"
+        })
+
+    # Получаем историю с учётом токенового бюджета
+    history = await db.get_messages_with_token_budget(
+        user_id, max_tokens=config.MAX_CONTEXT_TOKENS
+    )
+
+    # Ограничиваем количество сообщений
+    if len(history) > config.MAX_HISTORY:
+        history = history[-config.MAX_HISTORY:]
+
+    for h in history:
+        messages.append({"role": h["role"], "content": h["content"]})
+
+    # Добавляем текущее сообщение (если его ещё нет в истории)
+    if not history or history[-1]["content"] != user_text:
+        messages.append({"role": "user", "content": user_text})
+
+    return messages
+
+
+@router.message(F.text)
+async def handle_chat(message: types.Message) -> None:
+    """Основной обработчик текстовых сообщений."""
+    logger.info("→ handle_chat START, user_id=%s, text_len=%d", message.from_user.id, len(message.text or ""))
+
+    if not message.text:
+        await message.answer("❌ Поддерживаются только текстовые сообщения.")
+        return
+
+    user_id = message.from_user.id
+    user_text = message.text
+    _last_user_messages[user_id] = user_text
+
+    # Upsert user
+    await db.upsert_user(
+        user_id,
+        message.from_user.username,
+        message.from_user.first_name,
+        message.from_user.last_name,
+    )
+
+    # Save user message
+    tokens_estimate = glm_service.estimate_tokens(user_text)
+    await db.save_message(user_id, "user", user_text, tokens_estimate)
+
+    # Build messages for LLM
+    messages = await _build_messages(user_id, user_text)
+
+    # Typing action
+    stop_typing = asyncio.Event()
+    typing_task = asyncio.create_task(_keep_typing(message, stop_typing))
+
+    start_time = time.perf_counter()
+    bot_message = None
+
+    try:
+        logger.info("→ Calling GLM, messages_count=%d", len(messages))
+
+        if config.STREAMING_ENABLED:
+            # Streaming mode — обновляем сообщение по мере поступления чанков
+            response_text = ""
+            chunk_buffer = ""
+            last_update = time.perf_counter()
+            message_sent = False
+
+            async for chunk in glm_service.chat_stream(messages, user_id=user_id):
+                response_text += chunk
+                chunk_buffer += chunk
+
+                # Обновляем сообщение не чаще чем раз в N секунд
+                now = time.perf_counter()
+                if now - last_update >= config.STREAMING_UPDATE_INTERVAL and len(response_text) > 10:
+                    if not message_sent:
+                        bot_message = await message.answer(
+                            response_text + "▌",
+                            parse_mode=ParseMode.MARKDOWN,
+                        )
+                        message_sent = True
+                    else:
+                        try:
+                            await bot_message.edit_text(
+                                response_text + "▌",
+                                parse_mode=ParseMode.MARKDOWN,
+                            )
+                        except TelegramAPIError:
+                            pass  # Message not modified или другая ошибка
+                    last_update = now
+                    chunk_buffer = ""
+
+            # Финальное обновление
+            stop_typing.set()
+            await typing_task
+
+            if message_sent and bot_message:
+                try:
+                    await bot_message.edit_text(
+                        response_text,
+                        parse_mode=ParseMode.MARKDOWN,
+                        reply_markup=get_chat_buttons(),
+                    )
+                except TelegramAPIError:
+                    # Если edit не удался, отправляем новое
+                    await send_long_message(
+                        message, response_text,
+                        reply_markup=get_chat_buttons(),
+                    )
+            else:
+                await send_long_message(
+                    message, response_text,
+                    reply_markup=get_chat_buttons(),
+                )
+
+        else:
+            # Non-streaming mode
+            response = await glm_service.chat(messages, user_id=user_id)
+            stop_typing.set()
+            await typing_task
+            await send_long_message(message, response, reply_markup=get_chat_buttons())
+            response_text = response
+
+        duration_ms = (time.perf_counter() - start_time) * 1000
+        logger.info("← Response sent, duration=%.1fms, length=%d", duration_ms, len(response_text))
+
+        # Save assistant message
+        assistant_tokens = glm_service.estimate_tokens(response_text)
+        await db.save_message(user_id, "assistant", response_text, assistant_tokens)
+
+        # Trigger background summarization
+        asyncio.create_task(_maybe_summarize(user_id))
+
+    except LLMServiceError as e:
+        stop_typing.set()
+        await typing_task
+        logger.error("LLM Service Error: %s", e)
+        await message.answer(
+            "❌ <b>Ошибка модели:</b>\n"
+            f"<code>{str(e)[:200]}</code>\n\n"
+            "Попробуйте повторить запрос позже.",
+            parse_mode="HTML",
+        )
+
+    except Exception as e:
+        stop_typing.set()
+        await typing_task
+        logger.error("❌ Unexpected error in chat handler: %s", e, exc_info=True)
+        await message.answer(
+            "❌ <b>Неожиданная ошибка.</b>\n"
+            "Разработчик уведомлён. Попробуйте позже.",
+            parse_mode="HTML",
+        )

handlers commands.py

@@ -0,0 +1,149 @@
+import asyncio
+import logging
+from aiogram import Router, types, F
+from aiogram.filters import Command
+from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
+from database import db
+from config import config
+
+logger = logging.getLogger(__name__)
+router = Router()
+
+
+def get_main_menu() -> InlineKeyboardMarkup:
+    """Главное меню с быстрыми действиями."""
+    return InlineKeyboardMarkup(inline_keyboard=[
+        [
+            InlineKeyboardButton(text="🔄 Регенерировать", callback_data="regenerate"),
+            InlineKeyboardButton(text="🗑 Очистить память", callback_data="clear_memory"),
+        ],
+        [
+            InlineKeyboardButton(text="📊 Статистика", callback_data="show_stats"),
+            InlineKeyboardButton(text="⚙️ Настройки", callback_data="show_settings"),
+        ],
+    ])
+
+
+@router.message(Command("start"))
+async def cmd_start(message: types.Message) -> None:
+    await message.answer(
+        "👋 <b>Привет!</b> Я AI-ассистент на базе GLM-4.5 через NVIDIA NIM.\n\n"
+        "🧠 <b>Возможности:</b>\n"
+        "• Долговременная память (Neon PostgreSQL)\n"
+        "• Автоматическая суммаризация диалогов\n"
+        "• Fallback-модель при сбоях\n"
+        "• Streaming-ответы\n"
+        "• Rate limiting и мониторинг\n\n"
+        "Отправь любое сообщение — я отвечу.\n"
+        "Используй /help для списка команд.",
+        parse_mode="HTML",
+        reply_markup=get_main_menu(),
+    )
+
+
+@router.message(Command("help"))
+async def cmd_help(message: types.Message) -> None:
+    await message.answer(
+        "📋 <b>Команды:</b>\n\n"
+        "/start — Начать работу\n"
+        "/help — Помощь\n"
+        "/clear — Очистить историю сообщений\n"
+        "/stats — Статистика использования\n"
+        "/memory — Информация о памяти\n"
+        "/settings — Настройки бота\n"
+        "/ping — Проверка задержки\n\n"
+        "<b>Быстрые кнопки под ответом:</b>\n"
+        "🔄 Регенерировать — повторить генерацию\n"
+        "🗑 Очистить память — сбросить контекст\n"
+        "📊 Статистика — метрики и usage",
+        parse_mode="HTML",
+    )
+
+
+@router.message(Command("clear"))
+async def cmd_clear(message: types.Message) -> None:
+    count = await db.clear_history(message.from_user.id)
+    await message.answer(
+        f"🗑 <b>История очищена.</b>\n\n"
+        f"Удалено сообщений: <code>{count}</code>.\n"
+        f"Контекст и суммаризация сброшены.",
+        parse_mode="HTML",
+    )
+
+
+@router.message(Command("stats"))
+async def cmd_stats(message: types.Message) -> None:
+    stats = await db.get_stats(message.from_user.id)
+    await message.answer(
+        f"📊 <b>Статистика:</b>\n\n"
+        f"👥 Всего пользователей: <code>{stats['total_users']}</code>\n"
+        f"💬 Ваших сообщений: <code>{stats['user_messages']}</code>\n"
+        f"📨 Всего сообщений: <code>{stats['total_messages']}</code>\n"
+        f"📝 Суммаризировано: <code>{stats['summarized_messages']}</code>\n"
+        f"🔢 Токенов использовано: <code>{stats['total_tokens_used']}</code>\n"
+        f"⏱ Средняя задержка: <code>{stats['avg_latency_ms']} мс</code>",
+        parse_mode="HTML",
+    )
+
+
+@router.message(Command("memory"))
+async def cmd_memory(message: types.Message) -> None:
+    user_id = message.from_user.id
+    summary = await db.get_summary(user_id)
+    count = await db.count_unsummarized(user_id)
+    history = await db.get_messages(user_id, limit=5)
+
+    text = "🧠 <b>Память пользователя:</b>\n\n"
+
+    if summary:
+        text += f"📋 <b>Суммаризация:</b>\n<code>{summary[:500]}</code>"
+        if len(summary) > 500:
+            text += "..."
+        text += "\n\n"
+    else:
+        text += "📋 <b>Суммаризация:</b> <i>пока нет</i>\n\n"
+
+    text += f"💬 <b>Несуммаризированных сообщений:</b> <code>{count}</code>\n"
+    text += f"📚 <b>Лимит истории:</b> <code>{config.MAX_HISTORY}</code>\n"
+    text += f"🔢 <b>Лимит токенов:</b> <code>{config.MAX_CONTEXT_TOKENS}</code>\n\n"
+
+    if history:
+        text += "<b>Последние сообщения:</b>\n"
+        for h in history[-3:]:
+            preview = h['content'][:60].replace("<", "&lt;").replace(">", "&gt;")
+            text += f"• <i>{h['role']}</i>: {preview}...\n"
+
+    await message.answer(text, parse_mode="HTML")
+
+
+@router.message(Command("settings"))
+async def cmd_settings(message: types.Message) -> None:
+    kb = InlineKeyboardMarkup(inline_keyboard=[
+        [InlineKeyboardButton(text="🌡 Temperature", callback_data="set_temp")],
+        [InlineKeyboardButton(text="📏 Max Tokens", callback_data="set_max_tokens")],
+        [InlineKeyboardButton(text="🔙 Назад", callback_data="back_to_menu")],
+    ])
+    await message.answer(
+        "⚙️ <b>Настройки:</b>\n\n"
+        f"🌡 <b>Temperature:</b> <code>{config.GLM_TEMPERATURE}</code>\n"
+        f"📏 <b>Max Tokens:</b> <code>{config.GLM_MAX_TOKENS}</code>\n"
+        f"🔄 <b>Streaming:</b> <code>{'ON' if config.STREAMING_ENABLED else 'OFF'}</code>\n"
+        f"🛡 <b>Rate Limit:</b> <code>{config.RATE_LIMIT_REQUESTS_PER_MINUTE}/мин</code>\n"
+        f"💾 <b>Cache:</b> <code>{'ON' if config.CACHE_ENABLED else 'OFF'}</code>",
+        parse_mode="HTML",
+        reply_markup=kb,
+    )
+
+
+@router.message(Command("ping"))
+async def cmd_ping(message: types.Message) -> None:
+    start = asyncio.get_event_loop().time()
+    msg = await message.answer("🏓 <b>Pong!</b>", parse_mode="HTML")
+    end = asyncio.get_event_loop().time()
+    latency = (end - start) * 1000
+    await msg.edit_text(
+        f"🏓 <b>Pong!</b>\n\n"
+        f"⏱ Задержка Telegram: <code>{latency:.1f} мс</code>\n"
+        f"🎯 Бот активен и готов к работе.",
+        parse_mode="HTML",
+    )

middlewares rate_limit.py

@@ -0,0 +1,43 @@
+import logging
+from typing import Any, Awaitable, Callable, Dict
+from aiogram import BaseMiddleware
+from aiogram.types import Message, TelegramObject
+from database import db
+from config import config
+
+logger = logging.getLogger(__name__)
+
+
+class RateLimitMiddleware(BaseMiddleware):
+    """
+    Middleware для ограничения частоты запросов.
+    Хранит состояние в PostgreSQL (stateless — работает на нескольких инстансах).
+    """
+
+    async def __call__(
+        self,
+        handler: Callable[[TelegramObject, Dict[str, Any]], Awaitable[Any]],
+        event: TelegramObject,
+        data: Dict[str, Any],
+    ) -> Any:
+        if not isinstance(event, Message):
+            return await handler(event, data)
+
+        if not config.RATE_LIMIT_ENABLED:
+            return await handler(event, data)
+
+        user_id = event.from_user.id
+        allowed, remaining, reset_in = await db.check_rate_limit(user_id)
+
+        if not allowed:
+            logger.warning("Rate limit exceeded for user %s", user_id)
+            minutes = int(reset_in // 60) + 1
+            await event.answer(
+                f"⏳ Слишком много запросов. Попробуйте снова через {minutes} мин.",
+                show_alert=False,
+            )
+            return None
+
+        # Добавляем информацию о rate limit в data для логирования
+        data["rate_limit_remaining"] = remaining
+        return await handler(event, data)

services glm.py

@@ -0,0 +1,344 @@
+import asyncio
+import logging
+import time
+from typing import List, Dict, Any, Optional, AsyncGenerator
+
+import httpx
+import openai
+from openai import AsyncOpenAI
+
+from config import config
+from database import db
+
+logger = logging.getLogger(__name__)
+
+
+class LLMServiceError(Exception):
+    """Base exception for LLM service errors."""
+    pass
+
+
+class LLMTimeoutError(LLMServiceError):
+    """Timeout error with fallback exhausted."""
+    pass
+
+
+class LLMRateLimitError(LLMServiceError):
+    """Rate limit from provider."""
+    pass
+
+
+class GLMService:
+    """Production-ready GLM service with retry, fallback, streaming, metrics."""
+
+    def __init__(self) -> None:
+        # Granular timeouts for NVIDIA NIM
+        self.timeout = httpx.Timeout(
+            connect=config.TIMEOUT_CONNECT,
+            read=config.TIMEOUT_READ,
+            write=config.TIMEOUT_WRITE,
+            pool=config.TIMEOUT_POOL,
+        )
+
+        self.primary_client = AsyncOpenAI(
+            base_url=config.NVIDIA_BASE_URL,
+            api_key=config.NVIDIA_API_KEY,
+            timeout=self.timeout,
+            max_retries=0,  # управляем retry самостоятельно
+        )
+
+        self.fallback_client = AsyncOpenAI(
+            base_url=config.NVIDIA_BASE_URL,
+            api_key=config.NVIDIA_API_KEY,
+            timeout=self.timeout,
+            max_retries=0,
+        ) if config.FALLBACK_ENABLED else None
+
+        self.primary_model = config.PRIMARY_MODEL
+        self.fallback_model = config.FALLBACK_MODEL
+
+    # ═══════════════════════════════════════════════════════════════
+    # BLOCK: Exponential Retry with Jitter
+    # ═══════════════════════════════════════════════════════════════
+    def _calculate_delay(self, attempt: int) -> float:
+        """Экспоненциальная задержка с jitter."""
+        import random
+        delay = min(
+            config.RETRY_BASE_DELAY * (config.RETRY_EXPONENTIAL_BASE ** attempt),
+            config.RETRY_MAX_DELAY,
+        )
+        jitter = random.uniform(0, delay * 0.3)
+        return delay + jitter
+
+    def _is_retryable_error(self, error: Exception) -> bool:
+        """Определяет, стоит ли retry-ить ошибку."""
+        if isinstance(error, openai.APITimeoutError):
+            return True
+        if isinstance(error, openai.APIConnectionError):
+            return True
+        if isinstance(error, openai.RateLimitError):
+            return True
+        if isinstance(error, openai.InternalServerError):
+            return True
+        if isinstance(error, openai.APIStatusError):
+            if hasattr(error, 'status_code') and error.status_code in (429, 502, 503, 504):
+                return True
+        return False
+
+    # ═══════════════════════════════════════════════════════════════
+    # BLOCK: Core Chat with Retry and Fallback
+    # ═══════════════════════════════════════════════════════════════
+    async def chat(
+        self,
+        messages: List[Dict[str, str]],
+        user_id: Optional[int] = None,
+        temperature: Optional[float] = None,
+        max_tokens: Optional[int] = None,
+        stream: bool = False,
+    ) -> str:
+        """
+        Отправляет запрос к LLM с retry и fallback.
+        Возвращает полный текст ответа.
+        """
+        start_time = time.perf_counter()
+        model = self.primary_model
+        client = self.primary_client
+        used_fallback = False
+        last_error = None
+
+        params = self._build_params(
+            messages=messages,
+            model=model,
+            temperature=temperature,
+            max_tokens=max_tokens,
+            stream=stream,
+        )
+
+        # Retry loop for primary model
+        for attempt in range(config.MAX_RETRIES):
+            try:
+                logger.info(
+                    "→ LLM request: model=%s, attempt=%d/%d, messages=%d, stream=%s",
+                    model, attempt + 1, config.MAX_RETRIES, len(messages), stream
+                )
+
+                if stream and config.STREAMING_ENABLED:
+                    response_text = await self._stream_chat(client, params, user_id)
+                else:
+                    response = await client.chat.completions.create(**params)
+                    response_text = response.choices[0].message.content or ""
+
+                duration_ms = (time.perf_counter() - start_time) * 1000
+                logger.info(
+                    "← LLM response: model=%s, duration=%.1fms, length=%d, fallback=%s",
+                    model, duration_ms, len(response_text), used_fallback
+                )
+
+                # Save metrics
+                if config.METRICS_ENABLED:
+                    await db.save_metric(
+                        user_id=user_id,
+                        model=model,
+                        duration_ms=duration_ms,
+                        success=True,
+                    )
+
+                return response_text
+
+            except Exception as e:
+                last_error = e
+                duration_ms = (time.perf_counter() - start_time) * 1000
+                error_type = type(e).__name__
+
+                if not self._is_retryable_error(e):
+                    logger.error("Non-retryable error: %s", e)
+                    if config.METRICS_ENABLED:
+                        await db.save_metric(
+                            user_id=user_id,
+                            model=model,
+                            duration_ms=duration_ms,
+                            success=False,
+                            error_type=error_type,
+                        )
+                    raise LLMServiceError(f"Non-retryable error: {e}") from e
+
+                if attempt < config.MAX_RETRIES - 1:
+                    delay = self._calculate_delay(attempt)
+                    logger.warning(
+                        "⚠️ Retry %d/%d for model=%s after %.1fs: %s",
+                        attempt + 1, config.MAX_RETRIES, model, delay, e
+                    )
+                    await asyncio.sleep(delay)
+                else:
+                    logger.error("Primary model exhausted all retries: %s", e)
+
+        # Fallback model
+        if config.FALLBACK_ENABLED and self.fallback_client:
+            logger.warning("🔄 Switching to fallback model: %s", self.fallback_model)
+            model = self.fallback_model
+            client = self.fallback_client
+            used_fallback = True
+
+            try:
+                params["model"] = model
+                if stream and config.STREAMING_ENABLED:
+                    response_text = await self._stream_chat(client, params, user_id)
+                else:
+                    response = await client.chat.completions.create(**params)
+                    response_text = response.choices[0].message.content or ""
+
+                duration_ms = (time.perf_counter() - start_time) * 1000
+                logger.info(
+                    "← Fallback response: model=%s, duration=%.1fms, length=%d",
+                    model, duration_ms, len(response_text)
+                )
+
+                if config.METRICS_ENABLED:
+                    await db.save_metric(
+                        user_id=user_id,
+                        model=f"{model} (fallback)",
+                        duration_ms=duration_ms,
+                        success=True,
+                    )
+
+                return response_text
+
+            except Exception as e:
+                duration_ms = (time.perf_counter() - start_time) * 1000
+                logger.error("Fallback model also failed: %s", e)
+                if config.METRICS_ENABLED:
+                    await db.save_metric(
+                        user_id=user_id,
+                        model=f"{model} (fallback)",
+                        duration_ms=duration_ms,
+                        success=False,
+                        error_type=type(e).__name__,
+                    )
+                raise LLMTimeoutError(
+                    f"Both primary and fallback models failed. Last error: {last_error}"
+                ) from e
+
+        raise LLMTimeoutError(f"All retries exhausted. Last error: {last_error}")
+
+    # ═══════════════════════════════════════════════════════════════
+    # BLOCK: Streaming
+    # ═══════════════════════════════════════════════════════════════
+    async def _stream_chat(
+        self,
+        client: AsyncOpenAI,
+        params: Dict[str, Any],
+        user_id: Optional[int] = None,
+    ) -> str:
+        """Обрабатывает streaming-ответ и собирает полный текст."""
+        params["stream"] = True
+        params["stream_options"] = {"include_usage": True}
+
+        full_text = ""
+        usage = None
+
+        try:
+            stream = await client.chat.completions.create(**params)
+            async for chunk in stream:
+                if chunk.choices and chunk.choices[0].delta.content:
+                    full_text += chunk.choices[0].delta.content
+                if chunk.usage:
+                    usage = chunk.usage
+        except Exception as e:
+            logger.error("Streaming error: %s", e)
+            raise
+
+        if usage:
+            logger.info(
+                "Streaming complete: tokens_in=%d, tokens_out=%d",
+                usage.prompt_tokens or 0, usage.completion_tokens or 0
+            )
+
+        return full_text
+
+    async def chat_stream(
+        self,
+        messages: List[Dict[str, str]],
+        user_id: Optional[int] = None,
+    ) -> AsyncGenerator[str, None]:
+        """Yields text chunks for real-time Telegram updates."""
+        params = self._build_params(
+            messages=messages,
+            model=self.primary_model,
+            stream=True,
+        )
+        params["stream"] = True
+        params["stream_options"] = {"include_usage": True}
+
+        try:
+            stream = await self.primary_client.chat.completions.create(**params)
+            async for chunk in stream:
+                if chunk.choices and chunk.choices[0].delta.content:
+                    yield chunk.choices[0].delta.content
+        except Exception as e:
+            logger.error("Streaming generation failed: %s", e)
+            raise
+
+    # ═══════════════════════════════════════════════════════════════
+    # BLOCK: Summarization
+    # ═══════════════════════════════════════════════════════════════
+    async def summarize(self, dialog_text: str) -> str:
+        """Суммаризация диалога через LLM."""
+        start_time = time.perf_counter()
+        messages = [
+            {
+                "role": "system",
+                "content": (
+                    "Суммаризируй следующий диалог между пользователем и ассистентом. "
+                    "Сохрани ключевые факты, предпочтения пользователя, важные детали и контекст. "
+                    "Будь краток, максимум 4096 токенов. Используй русский язык."
+                )
+            },
+            {"role": "user", "content": dialog_text}
+        ]
+
+        try:
+            response = await self.primary_client.chat.completions.create(
+                model=self.primary_model,
+                messages=messages,
+                temperature=0.1,
+                max_tokens=config.SUMMARY_MAX_TOKENS,
+                timeout=httpx.Timeout(connect=10.0, read=60.0, write=10.0),
+            )
+            content = response.choices[0].message.content or ""
+            duration_ms = (time.perf_counter() - start_time) * 1000
+            logger.info("Summary generated in %.1fms, length=%d", duration_ms, len(content))
+            return content
+        except Exception as e:
+            logger.error("Summary generation failed: %s", e)
+            return ""
+
+    # ═══════════════════════════════════════════════════════════════
+    # BLOCK: Helpers
+    # ═══════════════════════════════════════════════════════════════
+    def _build_params(
+        self,
+        messages: List[Dict[str, str]],
+        model: str,
+        temperature: Optional[float] = None,
+        max_tokens: Optional[int] = None,
+        stream: bool = False,
+    ) -> Dict[str, Any]:
+        """Строит параметры запроса к API."""
+        return {
+            "model": model,
+            "messages": messages,
+            "temperature": temperature if temperature is not None else config.GLM_TEMPERATURE,
+            "top_p": config.GLM_TOP_P,
+            "frequency_penalty": config.GLM_FREQUENCY_PENALTY,
+            "presence_penalty": config.GLM_PRESENCE_PENALTY,
+            "max_tokens": max_tokens if max_tokens is not None else config.GLM_MAX_TOKENS,
+            "stream": stream,
+        }
+
+    def estimate_tokens(self, text: str) -> int:
+        """Грубая оценка количества токенов (1 token ≈ 0.75 английских слов или 0.5 русских)."""
+        # Простая эвристика: ~4 символа на токен для смешанного текста
+        return max(1, len(text) // 4)
+
+
+glm_service = GLMService()

utils helpers.py

@@ -0,0 +1,114 @@
+import logging
+import re
+from aiogram import types
+from aiogram.enums import ParseMode
+from config import config
+
+logger = logging.getLogger(__name__)
+MAX_LENGTH = config.MAX_MESSAGE_LENGTH
+
+
+def escape_markdown_v2(text: str) -> str:
+    """Экранирует спецсимволы для MarkdownV2 (Telegram)."""
+    # Символы, которые нужно экранировать в MarkdownV2
+    escape_chars = r"_\*\[\]\(\)~`>#+\-=|{}\.!"
+    return re.sub(f"([{re.escape(escape_chars)}])", r"\\1", text)
+
+
+def format_code_blocks(text: str) -> str:
+    """Гарантирует корректное закрытие code blocks."""
+    # Подсчёт открывающих и закрывающих ```
+    triple_backticks = text.count("```")
+    if triple_backticks % 2 != 0:
+        text += "
+```"
+    return text
+
+
+def split_message_smart(text: str, max_length: int = MAX_LENGTH) -> list[str]:
+    """
+    Разбивает текст на части, стараясь не ломать code blocks и параграфы.
+    """
+    if len(text) <= max_length:
+        return [text]
+
+    chunks = []
+    while text:
+        if len(text) <= max_length:
+            chunks.append(text)
+            break
+
+        # Ищем ближайший перенос строки перед max_length
+        split_at = text.rfind("\n", 0, max_length)
+        if split_at == -1:
+            split_at = text.rfind(" ", 0, max_length)
+        if split_at == -1:
+            split_at = max_length
+
+        chunk = text[:split_at].strip()
+        if chunk:
+            chunks.append(chunk)
+        text = text[split_at:].strip()
+
+    return chunks
+
+
+async def send_long_message(
+    message: types.Message,
+    text: str,
+    parse_mode: ParseMode = ParseMode.MARKDOWN,
+    reply_markup=None,
+) -> list[types.Message]:
+    """
+    Отправляет длинные сообщения частями с корректным Markdown.
+    Возвращает список отправленных сообщений.
+    """
+    text = format_code_blocks(text)
+    chunks = split_message_smart(text)
+    sent_messages = []
+
+    for i, chunk in enumerate(chunks):
+        try:
+            # Для последнего чанка добавляем reply_markup (кнопки)
+            markup = reply_markup if i == len(chunks) - 1 else None
+            sent = await message.answer(
+                chunk,
+                parse_mode=parse_mode,
+                reply_markup=markup,
+            )
+            sent_messages.append(sent)
+        except Exception as e:
+            logger.warning("Failed to send chunk with Markdown: %s. Sending as plain text.", e)
+            try:
+                sent = await message.answer(
+                    chunk,
+                    parse_mode=None,
+                    reply_markup=reply_markup if i == len(chunks) - 1 else None,
+                )
+                sent_messages.append(sent)
+            except Exception as e2:
+                logger.error("Failed to send chunk: %s", e2)
+
+    return sent_messages
+
+
+async def edit_or_send_message(
+    message: types.Message,
+    text: str,
+    last_bot_message: types.Message = None,
+    parse_mode: ParseMode = ParseMode.MARKDOWN,
+) -> types.Message:
+    """
+    Редактирует последнее сообщение бота или отправляет новое.
+    Используется для streaming-ответов.
+    """
+    text = format_code_blocks(text)
+
+    if last_bot_message and len(text) <= MAX_LENGTH:
+        try:
+            await last_bot_message.edit_text(text, parse_mode=parse_mode)
+            return last_bot_message
+        except Exception as e:
+            logger.debug("Edit failed, sending new message: %s", e)
+
+    return await message.answer(text, parse_mode=parse_mode)