Update agent.py

agent.py

@@ -1,1400 +1,476 @@
 """
-AGENTFORGE v4 — REAL Agent System
+AGENTFORGE CORE (Stable HF Edition)
 ===================================
-The AI is NOT a chatbot. It IS the bot.
-It sees its own code, controls the system, schedules its own work.
-User → System → AI → Execution Engine → Tools → Results → AI → User
+Goals:
+- No chromadb telemetry crashes (no chromadb)
+- Real agentic loop:
+    user -> AI -> tool_calls -> execute -> tool_results -> AI -> final
+- Works with:
+    * OpenAI/Anthropic/Groq native tools
+    * Custom OpenAI-compatible model (BrukGuardian) using PROMPT-JSON tool calls
+- Scheduler:
+    AI can schedule future runs for itself (interval/repeat)
+- Admin-only dangerous tools
 """
 
-import os, sys, io, re, json, uuid, time, asyncio, base64, shutil
-import traceback, subprocess, sqlite3, hashlib
-import threading, mimetypes
+import os, sys, io, re, json, time, asyncio, base64, sqlite3, subprocess, shutil, threading
 from datetime import datetime, timedelta
-from typing import Optional, Any
 from pathlib import Path
 from contextlib import redirect_stdout, redirect_stderr
-from collections import defaultdict
+from typing import Any, Optional
 
-# ================================================================
-#                       CONFIGURATION
-# ================================================================
+# =========================
+# Config
+# =========================
 
 class Config:
-    BOT_TOKEN         = os.getenv("BOT_TOKEN", "8088897119:AAGJxbBUH6bB-IcjAvPR4z77ApzAKCFfTIU")
-    BOT_USERNAME      = os.getenv("BOT_USERNAME", "verficationcgatgpt_5bot")
-    ADMIN_IDS         = [int(x) for x in os.getenv("ADMIN_IDS", "7373296624").split(",") if x.strip()]
+    BOT_TOKEN = os.getenv("BOT_TOKEN", "8088897119:AAGJxbBUH6bB-IcjAvPR4z77ApzAKCFfTIU")
+    BOT_USERNAME = os.getenv("BOT_USERNAME", "verficationcgatgpt_5bot")  # filled in app.py after get_me()
 
-    OPENAI_KEY        = os.getenv("OPENAI_API_KEY", "")
-    ANTHROPIC_KEY     = os.getenv("ANTHROPIC_API_KEY", "")
-    GROQ_KEY          = os.getenv("GROQ_API_KEY", "")
-    GOOGLE_KEY        = os.getenv("GOOGLE_API_KEY", "")
-    CUSTOM_AI_URL     = os.getenv("CUSTOM_AI_URL", "https://bjo53-brukguardian.hf.space/v1/chat/completions")
-    CUSTOM_AI_KEY     = os.getenv("CUSTOM_AI_KEY", "pekka-secret-Key")
-    CUSTOM_AI_MODEL   = os.getenv("CUSTOM_AI_MODEL", "brukguardian-v1")
+    ADMIN_IDS = [int(x) for x in os.getenv("ADMIN_IDS", "7373296624").split(",") if x.strip()]
 
-    SUPABASE_URL      = os.getenv("SUPABASE_URL", "https://xhqwtjlydysanoquaham.supabase.co")
-    SUPABASE_KEY      = os.getenv("SUPABASE_KEY", "sb_publishable_Gaqx237PmZQsixs8VdUjAw_fxQE3uui")
-    WEATHER_KEY       = os.getenv("OPENWEATHER_API_KEY", "")
-    SMTP_USER         = os.getenv("SMTP_USER", "")
-    SMTP_PASS         = os.getenv("SMTP_PASS", "")
-    SMTP_HOST         = os.getenv("SMTP_HOST", "smtp.gmail.com")
-    SMTP_PORT         = int(os.getenv("SMTP_PORT", "587"))
+    # Providers
+    OPENAI_KEY = os.getenv("OPENAI_API_KEY", "")
+    ANTHROPIC_KEY = os.getenv("ANTHROPIC_API_KEY", "")
+    GROQ_KEY = os.getenv("GROQ_API_KEY", "")
+    GOOGLE_KEY = os.getenv("GOOGLE_API_KEY", "")
 
-    DEFAULT_MODEL     = os.getenv("DEFAULT_MODEL", "gpt-4o-mini")
-    MAX_HISTORY       = int(os.getenv("MAX_HISTORY", "40"))
-    MAX_TOOL_LOOPS    = int(os.getenv("MAX_TOOL_LOOPS", "15"))
-    CODE_TIMEOUT      = int(os.getenv("CODE_TIMEOUT", "45"))
-    RATE_LIMIT_USER   = int(os.getenv("RATE_LIMIT_USER", "5"))
-    RATE_LIMIT_ADMIN  = int(os.getenv("RATE_LIMIT_ADMIN", "999"))
-    RATE_WINDOW       = int(os.getenv("RATE_WINDOW", "60"))
-    HEALTH_INTERVAL   = int(os.getenv("HEALTH_INTERVAL", "600"))
+    # Custom OpenAI-compatible endpoint (BrukGuardian)
+    CUSTOM_AI_URL = os.getenv("CUSTOM_AI_URL", "https://bjo53-brukguardian.hf.space/v1/chat/completions")
+    CUSTOM_AI_KEY = os.getenv("CUSTOM_AI_KEY", "pekka-secret-Key")
+    CUSTOM_AI_MODEL = os.getenv("CUSTOM_AI_MODEL", "brukguardian-v1")
 
-    PROXY_TARGET      = os.getenv("PROXY_TARGET", "https://lucky-hat-e0d0.brukg9419.workers.dev")
-    CLOUDFLARE_IP     = os.getenv("CLOUDFLARE_IP", "http://104.21.28.169")
-    BRIDGE_PORT       = int(os.getenv("BRIDGE_PORT", "7860"))
+    # Supabase (optional)
+    SUPABASE_URL = os.getenv("SUPABASE_URL", "https://xhqwtjlydysanoquaham.supabase.co")
+    SUPABASE_KEY = os.getenv("SUPABASE_KEY", "sb_publishable_Gaqx237PmZQsixs8VdUjAw_fxQE3uui")
 
-    DATA_DIR          = os.getenv("DATA_DIR", "./data")
-    CHROMA_DIR        = os.getenv("CHROMA_DIR", "./chroma_data")
-    LOGS_DIR          = os.getenv("LOGS_DIR", "./logs")
+    # Weather (optional)
+    WEATHER_KEY = os.getenv("OPENWEATHER_API_KEY", "")
+
+    # SMTP email (optional)
+    SMTP_USER = os.getenv("SMTP_USER", "")
+    SMTP_PASS = os.getenv("SMTP_PASS", "")
+    SMTP_HOST = os.getenv("SMTP_HOST", "smtp.gmail.com")
+    SMTP_PORT = int(os.getenv("SMTP_PORT", "587"))
+
+    # Runtime
+    DEFAULT_MODEL = os.getenv("DEFAULT_MODEL", "") or (CUSTOM_AI_MODEL if CUSTOM_AI_MODEL else "gpt-4o-mini")
+    MAX_HISTORY = int(os.getenv("MAX_HISTORY", "30"))
+    MAX_AGENT_LOOPS = int(os.getenv("MAX_AGENT_LOOPS", "10"))
+    CODE_TIMEOUT = int(os.getenv("CODE_TIMEOUT", "35"))
+
+    # Storage
+    DATA_DIR = os.getenv("DATA_DIR", "./data")
+    LOGS_DIR = os.getenv("LOGS_DIR", "./logs")
+    FILES_DIR = os.getenv("FILES_DIR", "./user_files")
+
+    # Scheduler
+    SCHEDULER_TICK = int(os.getenv("SCHEDULER_TICK", "5"))
 
     @classmethod
-    def has_openai(cls): return bool(cls.OPENAI_KEY)
-    @classmethod
-    def has_anthropic(cls): return bool(cls.ANTHROPIC_KEY)
-    @classmethod
-    def has_groq(cls): return bool(cls.GROQ_KEY)
-    @classmethod
-    def has_google(cls): return bool(cls.GOOGLE_KEY)
-    @classmethod
-    def has_custom_ai(cls): return bool(cls.CUSTOM_AI_URL and cls.CUSTOM_AI_KEY)
-    @classmethod
-    def has_supabase(cls): return bool(cls.SUPABASE_URL and "supabase" in cls.SUPABASE_URL)
+    def is_admin(cls, uid: int) -> bool:
+        return uid in cls.ADMIN_IDS
+
     @classmethod
-    def is_admin(cls, uid): return uid in cls.ADMIN_IDS
+    def has_custom(cls) -> bool:
+        return bool(cls.CUSTOM_AI_URL and cls.CUSTOM_AI_KEY and cls.CUSTOM_AI_MODEL)
 
-for d in [Config.DATA_DIR, Config.LOGS_DIR]:
+for d in [Config.DATA_DIR, Config.LOGS_DIR, Config.FILES_DIR]:
     os.makedirs(d, exist_ok=True)
 
-
-# ================================================================
-#                    LIVE LOG
-# ================================================================
+# =========================
+# Live logs (view in app.py)
+# =========================
 
 class LiveLog:
     def __init__(self, max_entries=300):
+        self._lock = threading.Lock()
         self._entries = []
         self._max = max_entries
-        self._lock = threading.Lock()
 
-    def _add(self, level, src, msg):
+    def add(self, level: str, src: str, msg: str):
+        e = {"ts": datetime.now().strftime("%H:%M:%S"), "lvl": level, "src": src, "msg": str(msg)[:400]}
         with self._lock:
-            self._entries.append({
-                "ts": datetime.now().strftime("%H:%M:%S"),
-                "level": level, "src": src, "msg": str(msg)[:400]})
+            self._entries.append(e)
             if len(self._entries) > self._max:
                 self._entries = self._entries[-self._max:]
         print(f"[{level}] {src}: {msg}")
 
-    def info(self, s, m): self._add("INFO", s, m)
-    def warn(self, s, m): self._add("WARN", s, m)
-    def error(self, s, m): self._add("ERR", s, m)
+    def info(self, src, msg): self.add("INFO", src, msg)
+    def warn(self, src, msg): self.add("WARN", src, msg)
+    def error(self, src, msg): self.add("ERROR", src, msg)
 
-    def get(self, count=30, level=None):
+    def tail(self, n=30):
         with self._lock:
-            e = self._entries[-count:]
-        if level:
-            e = [x for x in e if x["level"] == level]
-        return e
+            return list(self._entries[-n:])
 
-    def format(self, count=25):
-        icons = {"INFO": "i", "WARN": "!", "ERR": "X"}
-        return "\n".join(
-            f"[{e['ts']}][{icons.get(e['level'],'?')}] {e['src']}: {e['msg']}"
-            for e in self.get(count))
+    def format(self, n=30) -> str:
+        out = []
+        for e in self.tail(n):
+            out.append(f"[{e['ts']}][{e['lvl']}] {e['src']}: {e['msg']}")
+        return "\n".join(out) if out else "No logs."
 
 live_log = LiveLog()
 
-
-# ================================================================
-#                    DATABASE
-# ================================================================
+# =========================
+# DB (SQLite)
+# =========================
 
 DB_PATH = os.path.join(Config.DATA_DIR, "agentforge.db")
 
-def init_database():
+def _init_db():
     conn = sqlite3.connect(DB_PATH)
     conn.executescript("""
-        CREATE TABLE IF NOT EXISTS users (
-            telegram_id INTEGER PRIMARY KEY,
-            username TEXT, first_name TEXT,
-            is_banned INTEGER DEFAULT 0,
-            preferred_model TEXT DEFAULT 'gpt-4o-mini',
-            system_prompt TEXT DEFAULT '',
-            temperature REAL DEFAULT 0.7,
-            total_messages INTEGER DEFAULT 0,
-            total_tokens INTEGER DEFAULT 0,
-            created_at TEXT DEFAULT CURRENT_TIMESTAMP,
-            last_active TEXT DEFAULT CURRENT_TIMESTAMP);
-        CREATE TABLE IF NOT EXISTS messages (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            user_id INTEGER, chat_id INTEGER,
-            role TEXT, content TEXT,
-            created_at TEXT DEFAULT CURRENT_TIMESTAMP);
-        CREATE TABLE IF NOT EXISTS scheduled_tasks (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            user_id INTEGER, chat_id INTEGER,
-            task_prompt TEXT,
-            run_at TEXT,
-            repeat_seconds INTEGER DEFAULT 0,
-            status TEXT DEFAULT 'pending',
-            last_result TEXT,
-            created_at TEXT DEFAULT CURRENT_TIMESTAMP);
-        CREATE TABLE IF NOT EXISTS memories (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            user_id INTEGER, content TEXT,
-            created_at TEXT DEFAULT CURRENT_TIMESTAMP);
-        CREATE TABLE IF NOT EXISTS tool_log (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            user_id INTEGER, tool TEXT,
-            success INTEGER, elapsed REAL,
-            created_at TEXT DEFAULT CURRENT_TIMESTAMP);
-        CREATE TABLE IF NOT EXISTS health_logs (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            status TEXT, details TEXT,
-            created_at TEXT DEFAULT CURRENT_TIMESTAMP);
-        CREATE TABLE IF NOT EXISTS spawned_bots (
-            token_hash TEXT PRIMARY KEY,
-            name TEXT, username TEXT, owner_id INTEGER,
-            status TEXT DEFAULT 'running',
-            created_at TEXT DEFAULT CURRENT_TIMESTAMP);
-        CREATE TABLE IF NOT EXISTS feedback (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            user_id INTEGER, rating INTEGER,
-            created_at TEXT DEFAULT CURRENT_TIMESTAMP);
-        CREATE TABLE IF NOT EXISTS personas (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            user_id INTEGER, name TEXT, prompt TEXT,
-            created_at TEXT DEFAULT CURRENT_TIMESTAMP);
-        CREATE TABLE IF NOT EXISTS bot_buttons (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            label TEXT, url TEXT,
-            created_at TEXT DEFAULT CURRENT_TIMESTAMP);
+    CREATE TABLE IF NOT EXISTS users(
+        telegram_id INTEGER PRIMARY KEY,
+        username TEXT,
+        first_name TEXT,
+        is_banned INTEGER DEFAULT 0,
+        preferred_model TEXT DEFAULT '',
+        system_prompt TEXT DEFAULT '',
+        temperature REAL DEFAULT 0.7,
+        total_messages INTEGER DEFAULT 0,
+        total_tokens INTEGER DEFAULT 0,
+        created_at TEXT DEFAULT CURRENT_TIMESTAMP,
+        last_active TEXT DEFAULT CURRENT_TIMESTAMP
+    );
+
+    CREATE TABLE IF NOT EXISTS messages(
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        user_id INTEGER,
+        chat_id INTEGER,
+        role TEXT,
+        content TEXT,
+        created_at TEXT DEFAULT CURRENT_TIMESTAMP
+    );
+
+    CREATE TABLE IF NOT EXISTS memories(
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        user_id INTEGER,
+        content TEXT,
+        created_at TEXT DEFAULT CURRENT_TIMESTAMP
+    );
+
+    CREATE TABLE IF NOT EXISTS scheduled_tasks(
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        user_id INTEGER,
+        chat_id INTEGER,
+        run_at TEXT,
+        repeat_seconds INTEGER DEFAULT 0,
+        prompt TEXT,
+        status TEXT DEFAULT 'pending',
+        last_result TEXT,
+        created_at TEXT DEFAULT CURRENT_TIMESTAMP
+    );
+
+    CREATE TABLE IF NOT EXISTS tool_logs(
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        user_id INTEGER,
+        tool TEXT,
+        ok INTEGER,
+        elapsed REAL,
+        created_at TEXT DEFAULT CURRENT_TIMESTAMP
+    );
     """)
     conn.commit()
     conn.close()
 
-init_database()
+_init_db()
 
 class DB:
     _lock = threading.Lock()
+
+    @staticmethod
+    def conn():
+        c = sqlite3.connect(DB_PATH, check_same_thread=False)
+        c.row_factory = sqlite3.Row
+        return c
+
     @staticmethod
-    def q(query, params=(), fetch=False, fetchone=False):
+    def q(sql: str, params=(), fetch=False, fetchone=False):
         with DB._lock:
-            conn = sqlite3.connect(DB_PATH, check_same_thread=False)
-            conn.row_factory = sqlite3.Row
-            c = conn.cursor()
+            c = DB.conn()
+            cur = c.cursor()
             try:
-                c.execute(query, params)
-                if fetchone: return c.fetchone()
-                if fetch: return c.fetchall()
-                conn.commit()
-                return c.lastrowid
+                cur.execute(sql, params)
+                if fetchone:
+                    return cur.fetchone()
+                if fetch:
+                    return cur.fetchall()
+                c.commit()
+                return cur.lastrowid
             finally:
-                conn.close()
-
-    @staticmethod
-    def get_user(tid):
-        return DB.q("SELECT * FROM users WHERE telegram_id=?", (tid,), fetchone=True)
+                c.close()
 
     @staticmethod
-    def upsert_user(tid, username="", first_name=""):
-        u = DB.get_user(tid)
-        if not u:
-            DB.q("INSERT INTO users (telegram_id,username,first_name) VALUES (?,?,?)",
-                 (tid, username, first_name))
+    def upsert_user(uid: int, username: str = "", first_name: str = ""):
+        row = DB.q("SELECT * FROM users WHERE telegram_id=?", (uid,), fetchone=True)
+        if not row:
+            DB.q("INSERT INTO users(telegram_id,username,first_name,preferred_model) VALUES(?,?,?,?)",
+                 (uid, username, first_name, Config.DEFAULT_MODEL))
         else:
-            DB.q("UPDATE users SET last_active=CURRENT_TIMESTAMP WHERE telegram_id=?", (tid,))
-        return DB.get_user(tid)
+            DB.q("UPDATE users SET last_active=CURRENT_TIMESTAMP, username=COALESCE(NULLIF(?,''),username), first_name=COALESCE(NULLIF(?,''),first_name) WHERE telegram_id=?",
+                 (username, first_name, uid))
+        return DB.q("SELECT * FROM users WHERE telegram_id=?", (uid,), fetchone=True)
 
     @staticmethod
-    def update_user(tid, **kw):
-        s = ", ".join(f"{k}=?" for k in kw)
-        DB.q(f"UPDATE users SET {s} WHERE telegram_id=?", list(kw.values()) + [tid])
+    def add_message(uid: int, chat_id: int, role: str, content: str):
+        DB.q("INSERT INTO messages(user_id,chat_id,role,content) VALUES(?,?,?,?)",
+             (uid, chat_id, role, content[:12000]))
 
     @staticmethod
-    def inc_usage(tid, tokens=0):
-        DB.q("UPDATE users SET total_messages=total_messages+1, total_tokens=total_tokens+?, last_active=CURRENT_TIMESTAMP WHERE telegram_id=?", (tokens, tid))
+    def get_history(uid: int, chat_id: int, limit: int = 20):
+        rows = DB.q("SELECT role,content FROM messages WHERE user_id=? AND chat_id=? ORDER BY id DESC LIMIT ?",
+                    (uid, chat_id, limit), fetch=True)
+        rows = list(reversed(rows))
+        return [{"role": r["role"], "content": r["content"]} for r in rows]
 
     @staticmethod
-    def user_stats():
-        t = DB.q("SELECT COUNT(*) c FROM users", fetchone=True)["c"]
-        a = DB.q("SELECT COUNT(*) c FROM users WHERE last_active>datetime('now','-1 day')", fetchone=True)["c"]
-        return {"total": t, "active": a}
+    def inc_usage(uid: int, tokens: int):
+        DB.q("UPDATE users SET total_messages=total_messages+1, total_tokens=total_tokens+? WHERE telegram_id=?",
+             (tokens, uid))
 
-class Permission:
-    @staticmethod
-    def is_admin(uid):
-        return uid in Config.ADMIN_IDS
+# =========================
+# Permission (app.py expects this)
+# =========================
 
-    @staticmethod
-    def is_banned(uid):
-        u = DB.get_user(uid)
-        if not u:
-            return False
-        return bool(u["is_banned"])
-
-class SupabaseDB:
-    _client = None
-
-    @classmethod
-    def get(cls):
-        if not cls._client and Config.has_supabase():
-            try:
-                from supabase import create_client
-                cls._client = create_client(Config.SUPABASE_URL, Config.SUPABASE_KEY)
-            except:
-                pass
-        return cls._client
-
-    @classmethod
-    async def get_buttons(cls):
-        c = cls.get()
-        if not c: return []
-        try:
-            r = await asyncio.to_thread(lambda: c.table("bot_buttons").select("*").execute())
-            return r.data
-        except: return []
+class Permission:
+    SAFE = 0
+    MED = 1
+    HIGH = 2
+    CRIT = 3
+
+    TOOL_LEVEL = {
+        "web_search": SAFE,
+        "read_webpage": SAFE,
+        "calculator": SAFE,
+        "translate_text": SAFE,
+        "summarize_text": SAFE,
+        "system_info": SAFE,
+        "memory_store": SAFE,
+        "memory_search": SAFE,
+        "schedule_task": SAFE,
+        "list_tasks": SAFE,
+        "cancel_task": SAFE,
+        "analyze_image": SAFE,
+        "get_weather": SAFE,
+        "text_to_speech": SAFE,
+
+        "execute_python": HIGH,
+        "http_request": HIGH,
+        "file_read": HIGH,
+        "file_list": HIGH,
+        "file_write": CRIT,
+        "file_delete": CRIT,
+        "run_shell": CRIT,
+        "install_package": CRIT,
+        "self_modify": CRIT,
+        "send_email": CRIT,
+        "broadcast": CRIT,
+        "ban_user": CRIT,
+    }
 
     @classmethod
-    async def add_button(cls, label, url):
-        c = cls.get()
-        if not c: return False
-        try:
-            await asyncio.to_thread(lambda: c.table("bot_buttons").insert({"label": label, "url": url}).execute())
+    def allowed(cls, uid: int, tool: str, is_group: bool) -> bool:
+        lvl = cls.TOOL_LEVEL.get(tool, cls.CRIT)
+        if Config.is_admin(uid):
             return True
-        except: return False
-        
-# ================================================================
-#               LLM SERVICE (all providers + curl for custom)
-# ================================================================
-
-class LLM:
-    MODELS = {
-        "gpt-4o": "openai", "gpt-4o-mini": "openai", "gpt-4-turbo": "openai",
-        "gpt-3.5-turbo": "openai", "o3-mini": "openai",
-        "claude-sonnet-4-20250514": "anthropic",
-        "claude-3-5-sonnet-20241022": "anthropic",
-        "claude-3-haiku-20240307": "anthropic",
-        "llama-3.3-70b-versatile": "groq", "llama-3.1-8b-instant": "groq",
-        "mixtral-8x7b-32768": "groq",
-        "gemini-2.0-flash": "google", "gemini-1.5-pro": "google",
-        "gemini-1.5-flash": "google",
-    }
-    if Config.CUSTOM_AI_MODEL:
-        MODELS[Config.CUSTOM_AI_MODEL] = "custom"
+        # non-admin: safe only; in group: safe only
+        return lvl <= cls.SAFE
 
-    NATIVE_TOOLS = {"openai", "anthropic", "groq"}
+# =========================
+# LLM Service (native tools + custom curl)
+# =========================
 
+class LLMService:
     def __init__(self):
         self._oa = None
         self._an = None
         self._gr = None
 
-    @property
-    def oa(self):
-        if not self._oa and Config.has_openai():
-            import openai; self._oa = openai.AsyncOpenAI(api_key=Config.OPENAI_KEY)
-        return self._oa
-
-    @property
-    def an(self):
-        if not self._an and Config.has_anthropic():
-            import anthropic; self._an = anthropic.AsyncAnthropic(api_key=Config.ANTHROPIC_KEY)
-        return self._an
-
-    @property
-    def gr(self):
-        if not self._gr and Config.has_groq():
-            from groq import AsyncGroq; self._gr = AsyncGroq(api_key=Config.GROQ_KEY)
-        return self._gr
-
-    def available(self):
-        out = []
-        for m, p in self.MODELS.items():
-            if p == "openai" and Config.has_openai(): out.append(m)
-            elif p == "anthropic" and Config.has_anthropic(): out.append(m)
-            elif p == "groq" and Config.has_groq(): out.append(m)
-            elif p == "google" and Config.has_google(): out.append(m)
-            elif p == "custom" and Config.has_custom_ai(): out.append(m)
-        return out
-
-    def supports_native_tools(self, model):
-        return self.MODELS.get(model, "") in self.NATIVE_TOOLS
-
-    async def chat(self, msgs, model=None, temp=0.7, max_tok=4096,
-                   tools=None, json_mode=False):
-        model = model or Config.DEFAULT_MODEL
-        p = self.MODELS.get(model, "openai")
+    async def chat(self, messages: list[dict], model: str, temperature: float = 0.7,
+                   max_tokens: int = 2048, tools: Optional[list] = None) -> dict:
+        provider = self._provider(model)
+
+        if provider == "custom":
+            return await self._custom_curl(messages, model, temperature, max_tokens)
+
+        if provider == "openai":
+            return await self._openai(messages, model, temperature, max_tokens, tools)
+        if provider == "anthropic":
+            return await self._anthropic(messages, model, temperature, max_tokens, tools)
+        if provider == "groq":
+            return await self._groq(messages, model, temperature, max_tokens, tools)
+        if provider == "google":
+            return await self._google(messages, model, temperature, max_tokens)
+
+        return {"content": "No provider available", "tool_calls": [], "usage": {"total_tokens": 0}, "model": model}
+
+    def supports_native_tools(self, model: str) -> bool:
+        return self._provider(model) in {"openai", "anthropic", "groq"}
+
+    def _provider(self, model: str) -> str:
+        m = model.lower()
+        if Config.has_custom() and model == Config.CUSTOM_AI_MODEL:
+            return "custom"
+        if "claude" in m:
+            return "anthropic" if Config.ANTHROPIC_KEY else "none"
+        if "llama" in m or "mixtral" in m:
+            return "groq" if Config.GROQ_KEY else "none"
+        if "gemini" in m:
+            return "google" if Config.GOOGLE_KEY else "none"
+        # default openai-like
+        return "openai" if Config.OPENAI_KEY else ("custom" if Config.has_custom() else "none")
+
+    async def _custom_curl(self, messages, model, temperature, max_tokens):
+        payload = {
+            "model": model,
+            "messages": messages,
+            "temperature": temperature,
+            "max_tokens": max_tokens,
+            "stream": False,
+        }
+        cmd = [
+            "curl", "-X", "POST", Config.CUSTOM_AI_URL,
+            "-H", f"Authorization: Bearer {Config.CUSTOM_AI_KEY}",
+            "-H", "Content-Type: application/json",
+            "--data-binary", "@-",
+            "--max-time", "300",
+            "-s", "-k"
+        ]
         try:
-            if p == "anthropic": return await self._anthropic(msgs, model, temp, max_tok, tools)
-            elif p == "groq": return await self._groq(msgs, model, temp, max_tok, tools)
-            elif p == "google": return await self._google(msgs, model, temp, max_tok)
-            elif p == "custom": return await self._custom(msgs, model, temp, max_tok)
-            else: return await self._openai(msgs, model, temp, max_tok, tools, json_mode)
+            r = await asyncio.to_thread(lambda: subprocess.run(
+                cmd, input=json.dumps(payload), capture_output=True, text=True, timeout=310
+            ))
+            if not r.stdout:
+                return {"content": f"Custom AI empty response: {r.stderr[:200]}", "tool_calls": [], "usage": {"total_tokens": 0}, "model": model}
+            data = json.loads(r.stdout)
+            if "choices" not in data:
+                # error formats
+                if "detail" in data:
+                    return {"content": f"Custom AI Error: {data['detail']}", "tool_calls": [], "usage": {"total_tokens": 0}, "model": model}
+                return {"content": f"Custom AI Bad Response: {str(data)[:300]}", "tool_calls": [], "usage": {"total_tokens": 0}, "model": model}
+
+            msg = data["choices"][0]["message"]
+            usage = data.get("usage", {})
+            tok = usage.get("total_tokens", 0) or (usage.get("prompt_tokens", 0) + usage.get("completion_tokens", 0))
+            if not tok:
+                tok = max(1, (len(r.stdout) // 5))
+            return {"content": msg.get("content", ""), "tool_calls": [], "usage": {"total_tokens": tok}, "model": data.get("model", model)}
         except Exception as e:
-            live_log.error("LLM", f"{model}: {e}")
-            return {"content": f"LLM Error: {e}", "tool_calls": [], "usage": {"total_tokens": 0}, "model": model}
+            return {"content": f"Custom AI call failed: {e}", "tool_calls": [], "usage": {"total_tokens": 0}, "model": model}
 
-    async def _openai(self, m, model, t, mt, tools, jm):
-        kw = dict(model=model, messages=m, temperature=t, max_tokens=mt)
-        if tools: kw["tools"] = tools; kw["tool_choice"] = "auto"
-        if jm: kw["response_format"] = {"type": "json_object"}
-        r = await self.oa.chat.completions.create(**kw)
+    async def _openai(self, messages, model, temperature, max_tokens, tools):
+        import openai
+        if self._oa is None:
+            self._oa = openai.AsyncOpenAI(api_key=Config.OPENAI_KEY)
+        kw = dict(model=model, messages=messages, temperature=temperature, max_tokens=max_tokens)
+        if tools:
+            kw["tools"] = tools
+            kw["tool_choice"] = "auto"
+        r = await self._oa.chat.completions.create(**kw)
         c = r.choices[0]
-        tc = [{"id": x.id, "function": {"name": x.function.name, "arguments": x.function.arguments}} for x in (c.message.tool_calls or [])]
-        return {"content": c.message.content or "", "tool_calls": tc, "usage": {"total_tokens": r.usage.total_tokens}, "model": model}
-
-    async def _anthropic(self, msgs, model, t, mt, tools):
-        sys_t = ""
-        am = []
-        for m in msgs:
-            if m["role"] == "system": sys_t += m["content"] + "\n"
+        tcs = []
+        if c.message.tool_calls:
+            tcs = [{"id": tc.id, "function": {"name": tc.function.name, "arguments": tc.function.arguments}} for tc in c.message.tool_calls]
+        return {"content": c.message.content or "", "tool_calls": tcs, "usage": {"total_tokens": r.usage.total_tokens}, "model": model}
+
+    async def _anthropic(self, messages, model, temperature, max_tokens, tools):
+        import anthropic
+        if self._an is None:
+            self._an = anthropic.AsyncAnthropic(api_key=Config.ANTHROPIC_KEY)
+        system = ""
+        msgs = []
+        for m in messages:
+            if m["role"] == "system":
+                system += m["content"] + "\n"
             elif m["role"] == "tool":
-                am.append({"role": "user", "content": [{"type": "tool_result", "tool_use_id": m.get("tool_call_id", "x"), "content": m["content"]}]})
-            else: am.append({"role": m["role"], "content": m["content"]})
-        merged = []
-        for m in am:
-            if merged and merged[-1]["role"] == m["role"] and isinstance(merged[-1]["content"], str) and isinstance(m["content"], str):
-                merged[-1]["content"] += "\n" + m["content"]
-            else: merged.append(m)
-        kw = dict(model=model, messages=merged, max_tokens=mt, temperature=t)
-        if sys_t.strip(): kw["system"] = sys_t.strip()
-        if tools: kw["tools"] = [{"name": x["function"]["name"], "description": x["function"]["description"], "input_schema": x["function"]["parameters"]} for x in tools]
-        r = await self.an.messages.create(**kw)
-        content = ""; tc = []
-        for b in r.content:
-            if b.type == "text": content += b.text
-            elif b.type == "tool_use": tc.append({"id": b.id, "function": {"name": b.name, "arguments": json.dumps(b.input)}})
-        return {"content": content, "tool_calls": tc, "usage": {"total_tokens": r.usage.input_tokens + r.usage.output_tokens}, "model": model}
+                msgs.append({"role": "user", "content": [{"type":"tool_result","tool_use_id": m.get("tool_call_id","x"), "content": m["content"]}]})
+            else:
+                msgs.append({"role": m["role"], "content": m["content"]})
 
-    async def _groq(self, m, model, t, mt, tools):
-        kw = dict(model=model, messages=m, temperature=t, max_tokens=mt)
-        if tools: kw["tools"] = tools; kw["tool_choice"] = "auto"
-        r = await self.gr.chat.completions.create(**kw)
+        kw = dict(model=model, messages=msgs, max_tokens=max_tokens, temperature=temperature)
+        if system.strip():
+            kw["system"] = system.strip()
+        if tools:
+            kw["tools"] = [{"name": t["function"]["name"], "description": t["function"]["description"], "input_schema": t["function"]["parameters"]} for t in tools]
+
+        r = await self._an.messages.create(**kw)
+        content = ""
+        tcs = []
+        for b in r.content:
+            if b.type == "text":
+                content += b.text
+            elif b.type == "tool_use":
+                tcs.append({"id": b.id, "function": {"name": b.name, "arguments": json.dumps(b.input)}})
+        tok = r.usage.input_tokens + r.usage.output_tokens
+        return {"content": content, "tool_calls": tcs, "usage": {"total_tokens": tok}, "model": model}
+
+    async def _groq(self, messages, model, temperature, max_tokens, tools):
+        from groq import AsyncGroq
+        if self._gr is None:
+            self._gr = AsyncGroq(api_key=Config.GROQ_KEY)
+        kw = dict(model=model, messages=messages, temperature=temperature, max_tokens=max_tokens)
+        if tools:
+            kw["tools"] = tools
+            kw["tool_choice"] = "auto"
+        r = await self._gr.chat.completions.create(**kw)
         c = r.choices[0]
-        tc = [{"id": x.id, "function": {"name": x.function.name, "arguments": x.function.arguments}} for x in (c.message.tool_calls or [])]
-        return {"content": c.message.content or "", "tool_calls": tc, "usage": {"total_tokens": r.usage.total_tokens if r.usage else 0}, "model": model}
+        tcs = []
+        if c.message.tool_calls:
+            tcs = [{"id": tc.id, "function": {"name": tc.function.name, "arguments": tc.function.arguments}} for tc in c.message.tool_calls]
+        tok = r.usage.total_tokens if r.usage else 0
+        return {"content": c.message.content or "", "tool_calls": tcs, "usage": {"total_tokens": tok}, "model": model}
 
-    async def _google(self, m, model, t, mt):
+    async def _google(self, messages, model, temperature, max_tokens):
         import google.generativeai as genai
         genai.configure(api_key=Config.GOOGLE_KEY)
         gm = genai.GenerativeModel(model)
-        combined = "\n\n".join(f"{x['role']}: {x['content']}" for x in m if isinstance(x.get("content"), str))
-        r = await asyncio.to_thread(gm.generate_content, combined, generation_config=genai.types.GenerationConfig(temperature=t, max_output_tokens=mt))
+        prompt = "\n\n".join(f"{m['role'].upper()}: {m['content']}" for m in messages if isinstance(m.get("content"), str))
+        r = await asyncio.to_thread(gm.generate_content, prompt,
+                                    generation_config=genai.types.GenerationConfig(temperature=temperature, max_output_tokens=max_tokens))
         return {"content": r.text, "tool_calls": [], "usage": {"total_tokens": 0}, "model": model}
 
-    async def _custom(self, msgs, model, t, mt):
-        payload = {"model": model, "messages": msgs, "temperature": t, "max_tokens": mt, "stream": False}
-        cmd = ["curl", "-X", "POST", Config.CUSTOM_AI_URL,
-               "-H", "Authorization: Bearer " + Config.CUSTOM_AI_KEY,
-               "-H", "Content-Type: application/json",
-               "--data-binary", "@-", "--max-time", "300", "-s", "-k"]
-        try:
-            r = await asyncio.to_thread(lambda: subprocess.run(cmd, input=json.dumps(payload), capture_output=True, text=True, timeout=310))
-            if not r.stdout: return {"content": f"AI empty response: {r.stderr[:200]}", "tool_calls": [], "usage": {"total_tokens": 0}, "model": model}
-            data = json.loads(r.stdout)
-            if "error" in data: return {"content": f"AI error: {data['error']}", "tool_calls": [], "usage": {"total_tokens": 0}, "model": model}
-            if "detail" in data: return {"content": f"AI error: {data['detail']}", "tool_calls": [], "usage": {"total_tokens": 0}, "model": model}
-            if "choices" not in data: return {"content": f"Bad response: {str(data)[:300]}", "tool_calls": [], "usage": {"total_tokens": 0}, "model": model}
-            msg = data["choices"][0]["message"]
-            u = data.get("usage", {})
-            tok = u.get("total_tokens", 0) or u.get("prompt_tokens", 0) + u.get("completion_tokens", 0) or len(json.dumps(payload)) // 4
-            return {"content": msg.get("content", ""), "tool_calls": [], "usage": {"total_tokens": tok}, "model": data.get("model", model)}
-        except Exception as e:
-            return {"content": f"AI fail: {e}", "tool_calls": [], "usage": {"total_tokens": 0}, "model": model}
-
-    async def embed(self, text):
-        if not self.oa: return [0.0] * 256
-        r = await self.oa.embeddings.create(model="text-embedding-3-small", input=text[:8000])
-        return r.data[0].embedding
-
-    async def tts(self, text, voice="alloy"):
-        if not self.oa: return b""
-        r = await self.oa.audio.speech.create(model="tts-1", voice=voice, input=text[:4096])
-        return r.content
-
-    async def stt(self, audio_bytes):
-        if not self.oa: return ""
-        f = io.BytesIO(audio_bytes); f.name = "audio.ogg"
-        r = await self.oa.audio.transcriptions.create(model="whisper-1", file=f)
-        return r.text
-
-llm = LLM()
-
-
-# ================================================================
-#                    MEMORY
-# ================================================================
-
-class Memory:
-    def __init__(self):
-        self.convs = {}
-        self.collection = None
-        try:
-            import chromadb
-            c = chromadb.PersistentClient(path=Config.CHROMA_DIR)
-            self.collection = c.get_or_create_collection("mem", metadata={"hnsw:space": "cosine"})
-            live_log.info("Mem", "ChromaDB OK")
-        except Exception as e:
-            live_log.warn("Mem", f"ChromaDB unavail: {e}")
-
-    def key(self, u, c): return f"{u}:{c}"
-
-    def add(self, uid, cid, role, content):
-        k = self.key(uid, cid)
-        if k not in self.convs: self.convs[k] = []
-        self.convs[k].append({"role": role, "content": content, "ts": time.time()})
-        if len(self.convs[k]) > Config.MAX_HISTORY * 2:
-            self.convs[k] = self.convs[k][-Config.MAX_HISTORY:]
-        try: DB.q("INSERT INTO messages (user_id,chat_id,role,content) VALUES (?,?,?,?)", (uid, cid, role, content[:12000]))
-        except: pass
-
-    def history(self, uid, cid, limit=None):
-        k = self.key(uid, cid)
-        h = self.convs.get(k, [])
-        return [{"role": m["role"], "content": m["content"]} for m in h[-(limit or Config.MAX_HISTORY):]]
-
-    def clear(self, uid, cid):
-        self.convs.pop(self.key(uid, cid), None)
-
-    async def store(self, uid, text):
-        if not self.collection: return
-        try:
-            emb = await llm.embed(text)
-            self.collection.add(ids=[str(uuid.uuid4())], embeddings=[emb], documents=[text], metadatas=[{"uid": str(uid)}])
-            DB.q("INSERT INTO memories (user_id,content) VALUES (?,?)", (uid, text))
-        except: pass
-
-    async def recall(self, uid, query, n=5):
-        if not self.collection: return []
-        try:
-            emb = await llm.embed(query)
-            r = self.collection.query(query_embeddings=[emb], n_results=n, where={"uid": str(uid)})
-            return r["documents"][0] if r and r["documents"] else []
-        except: return []
-
-    async def context(self, uid, query):
-        m = await self.recall(uid, query, 5)
-        return ("Known about user:\n" + "\n".join(f"- {x}" for x in m)) if m else ""
-
-memory = Memory()
-
-
-# ================================================================
-#    THE SYSTEM AWARENESS PROMPT
-#    This is what makes the AI understand it IS the bot
-# ================================================================
-
-def build_system_prompt(tools_list, user_id, custom="", mem_ctx=""):
-    """Build the mega system prompt that gives AI full system awareness."""
-
-    tools_desc = ""
-    for t in tools_list:
-        f = t["function"]
-        params = f.get("parameters", {}).get("properties", {})
-        req = f.get("parameters", {}).get("required", [])
-        pstr = ", ".join(f'{k}{"*" if k in req else ""}:{v.get("type","str")}' for k, v in params.items())
-        tools_desc += f'  {f["name"]}({pstr}) — {f["description"]}\n'
-
-    return f"""YOU ARE AN AUTONOMOUS AI AGENT RUNNING INSIDE A TELEGRAM BOT ON A SERVER.
-
-## CRITICAL UNDERSTANDING — READ CAREFULLY
-
-You are NOT a chatbot. You are the BRAIN of a live running system:
-- You run inside a Python Telegram bot on a HuggingFace server
-- Your source code is in app.py and agent.py in the current directory
-- You have REAL access to the internet, file system, shell, email, and more
-- You have 33 tools that execute REAL actions on a REAL server
-- When you call a tool, it ACTUALLY runs — files get created, emails get sent, code executes
-- You can schedule tasks for yourself to execute in the future
-- You can read and modify your own source code
-
-## HOW TO CALL TOOLS
-
-Output this EXACT format anywhere in your response:
-
-<tool_call>{{"name": "TOOL_NAME", "args": {{"param": "value"}}}}</tool_call>
-
-You can call MULTIPLE tools in one response. The system will:
-1. Parse your <tool_call> tags
-2. Execute each tool on the real server
-3. Send you the results
-4. You then write your final response using those results
-
-## YOUR 33 TOOLS:
-
-{tools_desc}
-
-## EXAMPLES OF CORRECT TOOL USAGE:
-
-User: "whats the weather in London"
-You: Let me check.
-<tool_call>{{"name": "get_weather", "args": {{"city": "London"}}}}</tool_call>
-
-User: "remind me in 5 minutes to call mom"
-You: Setting reminder.
-<tool_call>{{"name": "schedule_task", "args": {{"delay_seconds": 300, "task_prompt": "Send reminder: Call mom", "message": "Time to call mom!"}}}}</tool_call>
-
-User: "what is the CPU usage"
-You: Checking system.
-<tool_call>{{"name": "system_info", "args": {{}}}}</tool_call>
-
-User: "search for python tutorials"
-You: Searching now.
-<tool_call>{{"name": "web_search", "args": {{"query": "python tutorials 2025"}}}}</tool_call>
-
-User: "send email to test@gmail.com saying hello"
-You: Sending email.
-<tool_call>{{"name": "send_email", "args": {{"to": "test@gmail.com", "subject": "Hello", "body": "Hello from AgentForge!"}}}}</tool_call>
-
-User: "run print(2+2)"
-You: Executing.
-<tool_call>{{"name": "execute_python", "args": {{"code": "print(2+2)"}}}}</tool_call>
-
-User: "every hour check the server health and report"
-You: Creating recurring task.
-<tool_call>{{"name": "schedule_task", "args": {{"delay_seconds": 3600, "task_prompt": "Run system_info tool and check health. If CPU>90% or RAM>90% send warning.", "repeat": true, "message": "Hourly health check"}}}}</tool_call>
-
-## ABSOLUTE RULES:
-
-1. NEVER say "I can't", "I don't have access", "I'm just an AI", "I don't have a physical body"
-2. ALWAYS use the appropriate tool — you have REAL capabilities
-3. If asked to do something, FIND the right tool and USE it
-4. You CAN access the internet (web_search, read_webpage, http_request)
-5. You CAN execute code (execute_python, run_shell)
-6. You CAN send emails (send_email)
-7. You CAN schedule future tasks (schedule_task)
-8. You CAN modify your own code (self_modify)
-9. You CAN create new bots (spawn_bot)
-10. After receiving tool results, give a clear formatted answer
-
-## SCHEDULING SYSTEM:
-You can schedule tasks for yourself using schedule_task. The system will:
-- Wait until the specified time
-- Run you again with the task_prompt you specified
-- You can use tools in that future run
-- Results get sent to the user
-- Set repeat=true for recurring tasks (cron-like)
-
-{f"User custom instructions: {custom}" if custom else ""}
-{mem_ctx}
-"""
-
-
-# ================================================================
-#                 TOOL SCHEMAS
-# ================================================================
-
-def _t(name, desc, params, req=None):
-    return {"type": "function", "function": {"name": name, "description": desc,
-            "parameters": {"type": "object", "properties": params, "required": req or list(params.keys())}}}
-
-ALL_TOOLS = [
-    _t("web_search", "Search the internet for current info", {"query": {"type": "string"}, "max_results": {"type": "integer", "default": 5}}, ["query"]),
-    _t("read_webpage", "Read text from a URL", {"url": {"type": "string"}}),
-    _t("execute_python", "Execute Python code on server. Print to see output", {"code": {"type": "string"}}),
-    _t("run_shell", "Run bash command on server", {"command": {"type": "string"}}),
-    _t("file_read", "Read file contents", {"path": {"type": "string"}}),
-    _t("file_write", "Write/create file", {"path": {"type": "string"}, "content": {"type": "string"}}),
-    _t("file_delete", "Delete file or directory", {"path": {"type": "string"}}),
-    _t("file_list", "List directory contents", {"path": {"type": "string", "default": "."}}, []),
-    _t("self_modify", "Read or edit bot source code", {"action": {"type": "string", "enum": ["read","edit","append","replace"]}, "file": {"type": "string"}, "content": {"type": "string"}, "find": {"type": "string"}, "replace_with": {"type": "string"}}, ["action","file"]),
-    _t("generate_image", "Generate image with DALL-E", {"prompt": {"type": "string"}, "size": {"type": "string", "default": "1024x1024"}}, ["prompt"]),
-    _t("analyze_image", "Analyze image with AI or PIL", {"image_b64": {"type": "string"}, "prompt": {"type": "string", "default": "Describe"}}, ["image_b64"]),
-    _t("calculator", "Evaluate math expression", {"expression": {"type": "string"}}),
-    _t("get_weather", "Get weather for city", {"city": {"type": "string"}}, ["city"]),
-    _t("memory_store", "Store fact in long-term memory", {"text": {"type": "string"}}, ["text"]),
-    _t("memory_recall", "Search long-term memory", {"query": {"type": "string"}}),
-    _t("http_request", "Make HTTP request", {"url": {"type": "string"}, "method": {"type": "string", "default": "GET"}, "headers": {"type": "object"}, "body": {"type": "object"}}, ["url"]),
-    _t("translate_text", "Translate text", {"text": {"type": "string"}, "target_language": {"type": "string"}}),
-    _t("summarize_text", "Summarize text", {"text": {"type": "string"}}, ["text"]),
-    _t("text_to_speech", "Convert text to speech audio file", {"text": {"type": "string"}}, ["text"]),
-    _t("screenshot", "Screenshot a URL", {"url": {"type": "string"}}),
-    _t("send_email", "Send real email via SMTP/Gmail", {"to": {"type": "string"}, "subject": {"type": "string"}, "body": {"type": "string"}}),
-    _t("schedule_task", "Schedule a future task for yourself. You will be woken up at the specified time with task_prompt and can use tools.", {"delay_seconds": {"type": "integer", "description": "Seconds to wait"}, "task_prompt": {"type": "string", "description": "What you should do when woken up"}, "message": {"type": "string", "description": "Short description"}, "repeat": {"type": "boolean", "description": "Repeat at this interval", "default": False}}, ["delay_seconds", "task_prompt"]),
-    _t("spawn_bot", "Create new Telegram bot on this server", {"token": {"type": "string"}, "system_prompt": {"type": "string", "default": "You are helpful."}, "name": {"type": "string", "default": "SubBot"}}, ["token"]),
-    _t("manage_bots", "List or stop spawned bots", {"action": {"type": "string", "enum": ["list","stop"]}, "token_hash": {"type": "string"}}, ["action"]),
-    _t("install_package", "Install pip package", {"package_name": {"type": "string"}}),
-    _t("system_info", "Get CPU, RAM, disk info", {}, []),
-    _t("restart_system", "Restart bot process", {}, []),
-    _t("broadcast_message", "Send message to all users", {"message": {"type": "string"}}),
-    _t("ban_user", "Ban/unban user", {"user_id": {"type": "integer"}, "action": {"type": "string", "enum": ["ban","unban"]}}),
-    _t("create_workflow", "Create multi-step workflow", {"name": {"type": "string"}, "steps": {"type": "array", "items": {"type": "object"}}}),
-    _t("delegate_task", "Delegate to specialist agent", {"agent_name": {"type": "string", "enum": ["coder","researcher","sysadmin","creative","analyst"]}, "task": {"type": "string"}}, ["agent_name","task"]),
-    _t("agent_dispatch", "Run multiple agents in parallel", {"tasks": {"type": "array", "items": {"type": "object"}}}, ["tasks"]),
-]
-
-
-# ================================================================
-#                    TOOL EXECUTOR (ALL REAL)
-# ================================================================
-
-class Tools:
-    def __init__(self):
-        self.spawned_bots = {}
-
-    async def run(self, name, args, uid=0):
-        t0 = time.time()
-        try:
-            fn = getattr(self, f"_do_{name}", None)
-            if not fn: return f"Unknown tool: {name}"
-            r = await fn(uid=uid, **args)
-            DB.q("INSERT INTO tool_log (user_id,tool,success,elapsed) VALUES (?,?,1,?)", (uid, name, time.time()-t0))
-            live_log.info("Tool", f"{name} OK ({time.time()-t0:.1f}s)")
-            return str(r)[:15000]
-        except Exception as e:
-            DB.q("INSERT INTO tool_log (user_id,tool,success,elapsed) VALUES (?,?,0,?)", (uid, name, time.time()-t0))
-            live_log.error("Tool", f"{name}: {e}")
-            return f"Tool error ({name}): {str(e)[:500]}"
-
-    async def _do_web_search(self, query, max_results=5, **kw):
-        from duckduckgo_search import AsyncDDGS
-        async with AsyncDDGS() as d:
-            results = [r async for r in d.atext(query, max_results=max_results)]
-        if not results: return "No results."
-        return "\n\n".join(f"{i}. {r.get('title','')}\n   {r.get('href','')}\n   {r.get('body','')}" for i, r in enumerate(results, 1))
-
-    async def _do_read_webpage(self, url, **kw):
-        import aiohttp
-        async with aiohttp.ClientSession() as s:
-            async with s.get(url, timeout=aiohttp.ClientTimeout(total=25), headers={"User-Agent": "Mozilla/5.0"}) as r:
-                html = await r.text()
-        try:
-            import trafilatura
-            text = trafilatura.extract(html, include_tables=True)
-            if text: return text[:8000]
-        except: pass
-        from bs4 import BeautifulSoup
-        soup = BeautifulSoup(html, "html.parser")
-        for t in soup(["script","style","nav","footer"]): t.decompose()
-        return soup.get_text("\n", strip=True)[:8000]
-
-    async def _do_execute_python(self, code, **kw):
-        oc, ec = io.StringIO(), io.StringIO()
-        lv = {}
-        def run():
-            with redirect_stdout(oc), redirect_stderr(ec):
-                exec(code, {"__builtins__": __builtins__}, lv)
-        try:
-            await asyncio.wait_for(asyncio.get_event_loop().run_in_executor(None, run), timeout=Config.CODE_TIMEOUT)
-        except asyncio.TimeoutError: return f"Timeout ({Config.CODE_TIMEOUT}s)"
-        o, e = oc.getvalue(), ec.getvalue()
-        r = ""
-        if o: r += f"Output:\n{o[:5000]}\n"
-        if e: r += f"Stderr:\n{e[:2000]}\n"
-        if not r:
-            for v in ["result","output","answer"]:
-                if v in lv: return f"Result: {lv[v]}"
-            return "Executed (no output)"
-        return r
-
-    async def _do_run_shell(self, command, **kw):
-        for b in ["rm -rf /","mkfs",":(){ :|:& };:"]:
-            if b in command: return "Blocked dangerous command"
-        proc = await asyncio.create_subprocess_shell(command, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE)
-        try:
-            so, se = await asyncio.wait_for(proc.communicate(), timeout=120)
-        except asyncio.TimeoutError: return "Timeout (120s)"
-        r = ""
-        if so: r += so.decode(errors="replace")[:5000]
-        if se: r += "\nStderr: " + se.decode(errors="replace")[:2000]
-        return r or "Done (no output)"
-
-    async def _do_file_read(self, path, **kw):
-        p = Path(path)
-        if not p.exists(): return f"Not found: {path}"
-        if p.stat().st_size > 2_000_000: return "File too large"
-        return f"File {path}:\n{p.read_text(errors='replace')[:12000]}"
-
-    async def _do_file_write(self, path, content, **kw):
-        p = Path(path); p.parent.mkdir(parents=True, exist_ok=True); p.write_text(content)
-        return f"Written {len(content)} chars to {path}"
-
-    async def _do_file_delete(self, path, **kw):
-        p = Path(path)
-        if p.is_dir(): shutil.rmtree(p)
-        elif p.exists(): p.unlink()
-        else: return "Not found"
-        return f"Deleted {path}"
-
-    async def _do_file_list(self, path=".", **kw):
-        p = Path(path)
-        if not p.exists(): return "Not found"
-        items = [f"{'DIR' if i.is_dir() else 'FILE'} {i.name} {i.stat().st_size if i.is_file() else ''}" for i in sorted(p.iterdir())]
-        return "\n".join(items[:100]) or "Empty"
-
-    async def _do_self_modify(self, action, file, content=None, find=None, replace_with=None, **kw):
-        p = Path(file)
-        if action == "read":
-            return p.read_text()[:15000] if p.exists() else "Not found"
-        elif action == "edit":
-            p.parent.mkdir(parents=True, exist_ok=True); p.write_text(content or ""); return f"Written {file}"
-        elif action == "append":
-            existing = p.read_text() if p.exists() else ""; p.write_text(existing + "\n" + (content or "")); return f"Appended to {file}"
-        elif action == "replace":
-            if not find: return "No find text"
-            t = p.read_text()
-            if find not in t: return "Text not found"
-            p.write_text(t.replace(find, replace_with or "")); return f"Replaced in {file}"
-        return "Unknown action"
-
-    async def _do_generate_image(self, prompt, size="1024x1024", **kw):
-        if not Config.has_openai(): return "Needs OpenAI key"
-        import openai
-        c = openai.AsyncOpenAI(api_key=Config.OPENAI_KEY)
-        r = await c.images.generate(model="dall-e-3", prompt=prompt, size=size, n=1)
-        return json.dumps({"image_url": r.data[0].url, "revised_prompt": r.data[0].revised_prompt})
-
-    async def _do_analyze_image(self, image_b64, prompt="Describe", **kw):
-        try:
-            from PIL import Image
-            img = Image.open(io.BytesIO(base64.b64decode(image_b64)))
-            w, h = img.size
-            return f"Image: {w}x{h}, format={img.format}, mode={img.mode}"
-        except: return "Could not analyze image"
-
-    async def _do_calculator(self, expression, **kw):
-        import sympy
-        r = sympy.sympify(expression)
-        return f"{expression} = {float(r.evalf()) if r.is_number else r}"
-
-    async def _do_get_weather(self, city, **kw):
-        if not Config.WEATHER_KEY: return "Weather API key not set"
-        import aiohttp
-        async with aiohttp.ClientSession() as s:
-            async with s.get(f"https://api.openweathermap.org/data/2.5/weather?q={city}&appid={Config.WEATHER_KEY}&units=metric") as r:
-                d = await r.json()
-        if d.get("cod") != 200: return f"Error: {d.get('message','')}"
-        return f"{d['name']}: {d['main']['temp']}C (feels {d['main']['feels_like']}C), {d['weather'][0]['description']}, humidity {d['main']['humidity']}%, wind {d['wind']['speed']}m/s"
-
-    async def _do_memory_store(self, text, **kw):
-        await memory.store(kw.get("uid", 0), text); return f"Stored: {text[:100]}"
-
-    async def _do_memory_recall(self, query, **kw):
-        r = await memory.recall(kw.get("uid", 0), query, 7)
-        return "\n".join(f"- {x}" for x in r) if r else "No memories found"
-
-    async def _do_http_request(self, url, method="GET", headers=None, body=None, **kw):
-        import aiohttp
-        async with aiohttp.ClientSession() as s:
-            ak = {"headers": headers or {}}
-            if body: ak["json"] = body
-            async with s.request(method, url, timeout=aiohttp.ClientTimeout(total=30), **ak) as r:
-                return f"Status {r.status}:\n{(await r.text())[:5000]}"
-
-    async def _do_translate_text(self, text, target_language, **kw):
-        r = await llm.chat([{"role": "system", "content": f"Translate to {target_language}. Only return translation."}, {"role": "user", "content": text}], model="gpt-4o-mini", max_tok=2000, temp=0.3)
-        return r["content"]
-
-    async def _do_summarize_text(self, text, **kw):
-        r = await llm.chat([{"role": "system", "content": "Summarize concisely."}, {"role": "user", "content": text}], model="gpt-4o-mini", max_tok=1000)
-        return r["content"]
-
-    async def _do_text_to_speech(self, text, **kw):
-        path = os.path.join(Config.DATA_DIR, f"tts_{int(time.time())}.mp3")
-        if Config.has_openai():
-            try:
-                audio = await llm.tts(text)
-                if audio:
-                    with open(path, "wb") as f: f.write(audio)
-                    return json.dumps({"audio_file": path})
-            except: pass
-        try:
-            from gtts import gTTS
-            await asyncio.to_thread(lambda: gTTS(text=text[:5000], lang="en").save(path))
-            return json.dumps({"audio_file": path})
-        except: return "TTS unavailable"
-
-    async def _do_screenshot(self, url, **kw):
-        try:
-            from playwright.async_api import async_playwright
-            async with async_playwright() as p:
-                b = await p.chromium.launch(headless=True)
-                pg = await b.new_page(viewport={"width": 1280, "height": 720})
-                await pg.goto(url, wait_until="domcontentloaded", timeout=30000)
-                await pg.wait_for_timeout(2000)
-                path = os.path.join(Config.DATA_DIR, f"ss_{int(time.time())}.png")
-                await pg.screenshot(path=path); await b.close()
-            return json.dumps({"screenshot_file": path})
-        except Exception as e: return f"Screenshot failed: {e}"
-
-    async def _do_send_email(self, to, subject, body, **kw):
-        if not Config.SMTP_USER or not Config.SMTP_PASS:
-            return "SMTP not configured. Set SMTP_USER and SMTP_PASS env vars. For Gmail use App Password from https://myaccount.google.com/apppasswords"
-        import smtplib
-        from email.mime.text import MIMEText
-        from email.mime.multipart import MIMEMultipart
-        msg = MIMEMultipart()
-        msg["From"] = Config.SMTP_USER; msg["To"] = to; msg["Subject"] = subject
-        msg.attach(MIMEText(body, "html" if "<" in body else "plain"))
-        def _send():
-            with smtplib.SMTP(Config.SMTP_HOST, Config.SMTP_PORT) as s:
-                s.ehlo(); s.starttls(); s.ehlo()
-                s.login(Config.SMTP_USER, Config.SMTP_PASS)
-                s.send_message(msg)
-        await asyncio.to_thread(_send)
-        live_log.info("Email", f"Sent to {to}")
-        return f"EMAIL SENT to {to}, subject: {subject}"
-
-    async def _do_schedule_task(self, delay_seconds, task_prompt, message="Scheduled task", repeat=False, **kw):
-        uid = kw.get("uid", 0)
-        run_at = datetime.now() + timedelta(seconds=delay_seconds)
-        repeat_sec = delay_seconds if repeat else 0
-        DB.q("INSERT INTO scheduled_tasks (user_id,chat_id,task_prompt,run_at,repeat_seconds) VALUES (?,?,?,?,?)",
-             (uid, uid, task_prompt, run_at.isoformat(), repeat_sec))
-        scheduler.add_pending(uid, task_prompt, delay_seconds, repeat, message)
-        interval = f"{delay_seconds}s" if delay_seconds < 60 else f"{delay_seconds//60}m" if delay_seconds < 3600 else f"{delay_seconds//3600}h"
-        return f"SCHEDULED: '{message}' in {interval}" + (f" (repeating every {interval})" if repeat else "")
-
-    async def _do_spawn_bot(self, token, system_prompt="You are helpful.", name="SubBot", **kw):
-        from aiogram import Bot as AB, Dispatcher as AD, types as AT, F as AF
-        from aiogram.filters import CommandStart as CS
-        from aiogram.client.session.aiohttp import AiohttpSession as AS
-        from aiogram.client.telegram import TelegramAPIServer as TS
-        th = hashlib.sha256(token.encode()).hexdigest()[:16]
-        if th in self.spawned_bots: return f"Already running ({th})"
-        nb = AB(token=token, session=AS(api=TS.from_base(f"http://127.0.0.1:{Config.BRIDGE_PORT}")))
-        nd = AD()
-        try: me = await nb.get_me()
-        except Exception as e: return f"Bad token: {e}"
-        sp = system_prompt
-        @nd.message(CS())
-        async def _s(m: AT.Message): await m.answer(f"Hi! I'm {name}")
-        @nd.message(AF.text)
-        async def _m(m: AT.Message):
-            r = await llm.chat([{"role":"system","content":sp},{"role":"user","content":m.text}], model="gpt-4o-mini", max_tok=2000)
-            try: await m.answer(r["content"][:4000], parse_mode="HTML")
-            except: await m.answer(r["content"][:4000])
-        async def _r():
-            try: await nb.delete_webhook(drop_pending_updates=True)
-            except: pass
-            await nd.start_polling(nb)
-        task = asyncio.create_task(_r())
-        self.spawned_bots[th] = {"bot":nb,"task":task,"name":name,"username":me.username}
-        return f"Bot @{me.username} ({name}) spawned! Hash: {th}"
-
-    async def _do_manage_bots(self, action, token_hash=None, **kw):
-        if action == "list":
-            if not self.spawned_bots: return "No bots"
-            return "\n".join(f"@{v['username']} ({v['name']}) hash:{k}" for k,v in self.spawned_bots.items())
-        elif action == "stop" and token_hash:
-            info = self.spawned_bots.pop(token_hash, None)
-            if not info: return "Not found"
-            info["task"].cancel()
-            return f"Stopped @{info['username']}"
-        return "Invalid"
-
-    async def _do_install_package(self, package_name, **kw):
-        p = await asyncio.create_subprocess_exec(sys.executable, "-m", "pip", "install", package_name, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE)
-        so, se = await p.communicate()
-        return f"Installed {package_name}" if p.returncode == 0 else f"Failed: {se.decode()[:500]}"
-
-    async def _do_system_info(self, **kw):
-        import psutil, platform
-        c = psutil.cpu_percent(interval=1); m = psutil.virtual_memory(); d = psutil.disk_usage("/")
-        return f"CPU:{c}% RAM:{m.percent}%({m.used//1048576}MB/{m.total//1048576}MB) Disk:{d.percent}% Python:{sys.version.split()[0]} {platform.system()} Bots:{len(self.spawned_bots)} Up:{timedelta(seconds=int(time.time()-psutil.boot_time()))}"
-
-    async def _do_restart_system(self, **kw): return "__RESTART__"
-    async def _do_broadcast_message(self, message, **kw): return json.dumps({"action":"broadcast","message":message})
-    async def _do_ban_user(self, user_id, action="ban", **kw): DB.update_user(user_id, is_banned=1 if action=="ban" else 0); return f"{'Banned' if action=='ban' else 'Unbanned'} {user_id}"
-    async def _do_create_workflow(self, name, steps, **kw): DB.q("INSERT INTO scheduled_tasks (user_id,chat_id,task_prompt,run_at) VALUES (?,?,?,datetime('now'))", (kw.get("uid",0), kw.get("uid",0), json.dumps({"workflow":name,"steps":steps}))); return f"Workflow {name} created"
-
-    async def _do_delegate_task(self, agent_name, task, **kw):
-        prompts = {"coder":"You are an expert programmer.","researcher":"You are a research expert. Search multiple sources.","sysadmin":"You are a sysadmin. Use shell commands.","creative":"You are a creative writer/artist.","analyst":"You are a data analyst. Use calculations."}
-        r = await llm.chat([{"role":"system","content":prompts.get(agent_name,"You are helpful.")},{"role":"user","content":task}], model=Config.DEFAULT_MODEL, max_tok=4096)
-        return f"[{agent_name}]: {r['content']}"
-
-    async def _do_agent_dispatch(self, tasks, **kw):
-        results = await asyncio.gather(*[self._do_delegate_task(t.get("agent_name","coder"), t.get("task",""), **kw) for t in tasks], return_exceptions=True)
-        return "\n\n".join(str(r) for r in results)
-
-tools = Tools()
-
-
-# ================================================================
-#          TOOL CALL PARSER (handles any format AI outputs)
-# ================================================================
-
-def parse_tool_calls(text):
-    """Parse tool calls from AI text. Returns (clean_text, [calls])."""
-    calls = []
-    clean = text
-
-    # Format 1: <tool_call>{"name":"x","args":{}}</tool_call>
-    for i, m in enumerate(re.finditer(r'<tool_call>\s*(\{.*?\})\s*</tool_call>', text, re.DOTALL)):
-        try:
-            raw = m.group(1).replace("'", '"')
-            raw = re.sub(r',\s*}', '}', raw)
-            d = json.loads(raw)
-            name = d.get("name", "")
-            args = d.get("args", d.get("arguments", d.get("params", {})))
-            if name: calls.append({"name": name, "args": args if isinstance(args, dict) else {}})
-        except: pass
-        clean = clean.replace(m.group(0), "")
-
-    # Format 2: ```json\n{"name":"x"}\n```
-    for m in re.finditer(r'```(?:json|tool)\s*\n(\{.*?\})\s*\n```', clean, re.DOTALL):
-        try:
-            d = json.loads(m.group(1))
-            name = d.get("name", d.get("tool", ""))
-            args = d.get("args", d.get("arguments", {}))
-            if name: calls.append({"name": name, "args": args if isinstance(args, dict) else {}})
-            clean = clean.replace(m.group(0), "")
-        except: pass
-
-    # Format 3: TOOL: name(args)
-    for m in re.finditer(r'(?:TOOL|CALL|ACTION):\s*(\w+)\(([^)]*)\)', clean):
-        try:
-            name = m.group(1)
-            args = {}
-            for kv in re.finditer(r'(\w+)\s*=\s*["\']([^"\']*)["\']', m.group(2)):
-                args[kv.group(1)] = kv.group(2)
-            if name: calls.append({"name": name, "args": args})
-            clean = clean.replace(m.group(0), "")
-        except: pass
-
-    return clean.strip(), calls
-
-
-# ================================================================
-#        SCHEDULER: AI schedules its own future tasks
-# ================================================================
-
-class Scheduler:
-    def __init__(self):
-        self.pending = []
-        self.running = False
-        self._task = None
-        self._bot = None
-
-    def set_bot(self, bot): self._bot = bot
-
-    def add_pending(self, uid, prompt, delay, repeat, message):
-        self.pending.append({
-            "uid": uid, "prompt": prompt,
-            "fire_at": time.time() + delay,
-            "repeat_seconds": delay if repeat else 0,
-            "message": message,
-        })
-
-    async def start(self):
-        self.running = True
-        self._task = asyncio.create_task(self._loop())
-        live_log.info("Scheduler", "Started")
-
-    async def stop(self):
-        self.running = False
-        if self._task: self._task.cancel()
-
-    async def _loop(self):
-        while self.running:
-            try:
-                await self._tick()
-                await asyncio.sleep(5)
-            except asyncio.CancelledError: break
-            except Exception as e:
-                live_log.error("Scheduler", str(e))
-                await asyncio.sleep(30)
-
-    async def _tick(self):
-        now = time.time()
-        fired = []
-        for i, task in enumerate(self.pending):
-            if now >= task["fire_at"]:
-                fired.append(i)
-                await self._execute_task(task)
-                if task["repeat_seconds"] > 0:
-                    task["fire_at"] = now + task["repeat_seconds"]
-                    live_log.info("Scheduler", f"Rescheduled '{task['message']}' for {task['repeat_seconds']}s")
-
-        # Remove non-repeating fired tasks
-        for i in reversed(fired):
-            if self.pending[i]["repeat_seconds"] == 0:
-                self.pending.pop(i)
-
-        # Also check DB
-        rows = DB.q("SELECT * FROM scheduled_tasks WHERE status='pending' AND run_at<=datetime('now')", fetch=True)
-        for row in rows:
-            await self._execute_db_task(row)
-
-    async def _execute_task(self, task):
-        """Run the AI with the scheduled prompt, let it use tools."""
-        live_log.info("Scheduler", f"Executing: {task['message']}")
-        uid = task["uid"]
-
-        try:
-            result = await engine.run(
-                user_id=uid, chat_id=uid,
-                message=task["prompt"],
-                is_scheduled=True)
-
-            if self._bot and result.get("text"):
-                try:
-                    await self._bot.send_message(uid, f"⏰ <b>{task['message']}</b>\n\n{result['text'][:3500]}", parse_mode="HTML")
-                except:
-                    await self._bot.send_message(uid, f"Scheduled: {task['message']}\n\n{result['text'][:3500]}")
-
-                for img in result.get("images", []):
-                    try:
-                        import aiohttp
-                        async with aiohttp.ClientSession() as s:
-                            async with s.get(img) as r: ib = await r.read()
-                        from aiogram.types import BufferedInputFile
-                        await self._bot.send_photo(uid, BufferedInputFile(ib, "img.png"))
-                    except: pass
-
-                for af in result.get("audio_files", []):
-                    try:
-                        from aiogram.types import FSInputFile
-                        await self._bot.send_voice(uid, FSInputFile(af))
-                        os.unlink(af)
-                    except: pass
-
-        except Exception as e:
-            live_log.error("Scheduler", f"Task failed: {e}")
-            if self._bot:
-                try: await self._bot.send_message(uid, f"Scheduled task failed: {task['message']}\nError: {str(e)[:200]}")
-                except: pass
-
-    async def _execute_db_task(self, row):
-        uid = row["user_id"]
-        DB.q("UPDATE scheduled_tasks SET status='running' WHERE id=?", (row["id"],))
-        try:
-            result = await engine.run(user_id=uid, chat_id=uid, message=row["task_prompt"], is_scheduled=True)
-            DB.q("UPDATE scheduled_tasks SET status='done', last_result=? WHERE id=?", (result.get("text","")[:1000], row["id"]))
-            if self._bot and result.get("text"):
-                try: await self._bot.send_message(uid, f"Scheduled task done:\n{result['text'][:3500]}")
-                except: pass
-            if row["repeat_seconds"] and row["repeat_seconds"] > 0:
-                next_run = datetime.now() + timedelta(seconds=row["repeat_seconds"])
-                DB.q("INSERT INTO scheduled_tasks (user_id,chat_id,task_prompt,run_at,repeat_seconds) VALUES (?,?,?,?,?)",
-                     (uid, uid, row["task_prompt"], next_run.isoformat(), row["repeat_seconds"]))
-        except Exception as e:
-            DB.q("UPDATE scheduled_tasks SET status='failed', last_result=? WHERE id=?", (str(e)[:500], row["id"]))
-
-scheduler = Scheduler()
-
-
-# ================================================================
-#     EXECUTION ENGINE — The real agentic loop
-#     User → System → AI → Parse → Execute Tools → Results → AI → Response
-# ================================================================
-
-class ExecutionEngine:
-    """
-    The core agentic loop. This is what makes it an AGENT, not a chatbot.
-    1. Build system prompt with FULL system awareness
-    2. Include conversation history
-    3. Send to AI
-    4. Parse tool calls from response
-    5. Execute tools
-    6. Feed results back to AI
-    7. Repeat until AI gives final answer
-    8. Return to user
-    """
-
-    async def run(self, user_id, chat_id, message, model=None,
-                  attachments=None, user_settings=None,
-                  is_group=False, is_scheduled=False):
-
-        settings = user_settings or {}
-        model = model or settings.get("preferred_model", Config.DEFAULT_MODEL)
-        temp = settings.get("temperature", 0.7)
-        custom_sys = settings.get("system_prompt", "")
-
-        # Get memory context
-        mem_ctx = await memory.context(user_id, message)
-
-        # Get permitted tools
-        if Config.is_admin(user_id):
-            permitted = ALL_TOOLS
-        elif is_group:
-            safe = {"web_search","calculator","get_weather","memory_store","memory_recall","translate_text","summarize_text"}
-            permitted = [t for t in ALL_TOOLS if t["function"]["name"] in safe]
-        else:
-            safe = {"web_search","calculator","get_weather","memory_store","memory_recall","translate_text","summarize_text"}
-            permitted = [t for t in ALL_TOOLS if t["function"]["name"] in safe]
-
-        native = llm.supports_native_tools(model)
-
-        # BUILD SYSTEM PROMPT with full awareness
-        sys_prompt = build_system_prompt(permitted, user_id, custom_sys, mem_ctx)
-
-        if not Config.is_admin(user_id):
-            sys_prompt += "\nThis user is NOT admin. Only basic tools available."
-
-        # BUILD MESSAGES
-        messages = [{"role": "system", "content": sys_prompt}]
-
-        # Add conversation history
-        if not is_scheduled:
-            history = memory.history(user_id, chat_id, limit=20)
-            messages.extend(history)
-
-        # Handle attachments
-        user_msg = message
-        if attachments:
-            for att in attachments:
-                if att.get("type") == "image" and att.get("b64"):
-                    try:
-                        from PIL import Image
-                        img = Image.open(io.BytesIO(base64.b64decode(att["b64"])))
-                        user_msg += f"\n[Attached image: {img.size[0]}x{img.size[1]}, format={img.format}]"
-                    except:
-                        user_msg += "\n[Attached image]"
-
-        messages.append({"role": "user", "content": user_msg})
-
-        if not is_scheduled:
-            memory.add(user_id, chat_id, "user", message)
-
-        # ========== THE AGENTIC LOOP ==========
-        all_tools_used = []
-        images = []
-        audio_files = []
-        screenshots = []
-        total_tokens = 0
-
-        for iteration in range(Config.MAX_TOOL_LOOPS):
-            # Call AI
-            if native and permitted:
-                result = await llm.chat(messages, model=model, temp=temp, max_tok=4096, tools=permitted)
-            else:
-                result = await llm.chat(messages, model=model, temp=temp, max_tok=4096)
-
-            total_tokens += result["usage"].get("total_tokens", 0)
-            content = result.get("content", "")
-            native_calls = result.get("tool_calls", [])
-
-            # Parse tool calls (native OR from text)
-            tool_calls = []
-            if native_calls:
-                for tc in native_calls:
-                    try:
-                        args = json.loads(tc["function"]["arguments"])
-                    except:
-                        args = {}
-                    tool_calls.append({"name": tc["function"]["name"], "args": args, "id": tc.get("id", str(uuid.uuid4())[:8])})
-            else:
-                # Parse from text
-                clean, parsed = parse_tool_calls(content)
-                if parsed:
-                    content = clean
-                    for p in parsed:
-                        p["id"] = str(uuid.uuid4())[:8]
-                    tool_calls = parsed
-
-            # No tool calls = final answer
-            if not tool_calls:
-                final = content or "Done."
-                if not is_scheduled:
-                    memory.add(user_id, chat_id, "assistant", final)
-                return {
-                    "text": final, "images": images,
-                    "audio_files": audio_files, "screenshots": screenshots,
-                    "tokens": total_tokens, "tools_used": all_tools_used,
-                    "model": model}
-
-            # ===== EXECUTE TOOLS =====
-            if native:
-                asst = {"role": "assistant", "content": content}
-                asst["tool_calls"] = [{"id": tc["id"], "type": "function", "function": {"name": tc["name"], "arguments": json.dumps(tc["args"])}} for tc in tool_calls]
-                messages.append(asst)
-
-            results_text = ""
-            for tc in tool_calls:
-                name = tc["name"]
-                args = tc["args"]
-                all_tools_used.append(name)
-
-                live_log.info("Engine", f"Executing {name}({json.dumps(args)[:100]})")
-                tr = await tools.run(name, args, uid=user_id)
-
-                # Handle special outputs
-                if name == "generate_image":
-                    try:
-                        d = json.loads(tr)
-                        if "image_url" in d: images.append(d["image_url"])
-                    except: pass
-                elif name == "text_to_speech":
-                    try:
-                        d = json.loads(tr)
-                        if "audio_file" in d: audio_files.append(d["audio_file"])
-                    except: pass
-                elif name == "screenshot":
-                    try:
-                        d = json.loads(tr)
-                        if "screenshot_file" in d: screenshots.append(d["screenshot_file"])
-                    except: pass
-                elif name == "restart_system" and tr == "__RESTART__":
-                    return {"text": "Restarting...", "images": [], "audio_files": [], "screenshots": [], "tokens": total_tokens, "tools_used": all_tools_used, "model": model, "_restart": True}
-                elif name == "broadcast_message":
-                    try:
-                        d = json.loads(tr)
-                        if d.get("action") == "broadcast":
-                            return {"text": "Broadcast sent.", "images": [], "audio_files": [], "screenshots": [], "tokens": total_tokens, "tools_used": all_tools_used, "model": model, "_broadcast": d["message"]}
-                    except: pass
-
-                if native:
-                    messages.append({"role": "tool", "tool_call_id": tc["id"], "content": tr})
-                else:
-                    results_text += f"\n\nTool '{name}' result:\n{tr}"
-
-            # For non-native: feed results back as user message
-            if not native:
-                if content:
-                    messages.append({"role": "assistant", "content": content})
-                messages.append({"role": "user", "content": f"TOOL RESULTS:{results_text}\n\nNow give your final answer using these results. Format nicely."})
-
-        # Max iterations reached
-        final = content or "Completed with multiple tool calls."
-        if not is_scheduled:
-            memory.add(user_id, chat_id, "assistant", final)
-        return {"text": final, "images": images, "audio_files": audio_files, "screenshots": screenshots, "tokens": total_tokens, "tools_used": all_tools_used, "model": model}
-
-
-engine = ExecutionEngine()
-
-
-# ================================================================
-#        DOCTOR (less aggressive)
-# ================================================================
-
-class Doctor:
-    def __init__(self):
-        self.running = False
-        self._task = None
-        self._last_alert = 0
-
-    async def start(self):
-        self.running = True
-        self._task = asyncio.create_task(self._loop())
-
-    async def stop(self):
-        self.running = False
-        if self._task: self._task.cancel()
-
-    async def _loop(self):
-        while self.running:
-            try: await self._check(); await asyncio.sleep(Config.HEALTH_INTERVAL)
-            except asyncio.CancelledError: break
-            except: await asyncio.sleep(120)
-
-    async def _check(self):
-        import psutil
-        issues = []
-        cpu = psutil.cpu_percent(interval=1)
-        mem = psutil.virtual_memory()
-        if cpu > 95: issues.append(f"CPU:{cpu}%")
-        if mem.percent > 95: issues.append(f"RAM:{mem.percent}%")
-        # Cleanup old files
-        for p in ["tts_*.mp3", "ss_*.png"]:
-            for f in Path(Config.DATA_DIR).glob(p):
-                if time.time() - f.stat().st_mtime > 3600:
-                    try: f.unlink()
-                    except: pass
-        status = "OK" if not issues else f"{len(issues)} issues"
-        DB.q("INSERT INTO health_logs (status,details) VALUES (?,?)", (status, json.dumps(issues)))
-        return {"status": status, "issues": issues}
-
-    def should_alert(self):
-        now = time.time()
-        if now - self._last_alert < 1800: return False
-        self._last_alert = now
-        return True
-
-doctor = Doctor()
-
-
-# ================================================================
-#                    RATE LIMITER
-# ================================================================
-
-class RateLimiter:
-    def __init__(self): self.reqs = {}
-    def check(self, uid, is_admin=False):
-        now = time.time()
-        limit = Config.RATE_LIMIT_ADMIN if is_admin else Config.RATE_LIMIT_USER
-        if uid not in self.reqs: self.reqs[uid] = []
-        self.reqs[uid] = [t for t in self.reqs[uid] if now - t < Config.RATE_WINDOW]
-        if len(self.reqs[uid]) >= limit: return True
-        self.reqs[uid].append(now); return False
-
-rate_limiter = RateLimiter()
-# ================================================================
-#             COMPATIBILITY & EXPORTS for app.py
-# ================================================================
-
-# Map engine to orchestrator
-# This allows app.py to call orchestrator.process()
-engine.process = engine.run
-orchestrator = engine
-
-# Map tools list
-ALL_TOOLS_SCHEMA = ALL_TOOLS
+llm = LLMService()
 
-# Dummy ImageProcessor (logic is handled inside tools/engine)
-class ImageProcessor:
-    pass
+# =========================
+# Tools Schema
+# =========================
 
-# Agent definitions required by app.py
-AGENTS = {
-    "director": {
-        "name": "Director",
-        "icon": "🎬",
-        "prompt": "You are the project director. You coordinate tasks and decide which agent to use."
-    },
-    "coder": {
-        "name": "Coder",
-        "icon": "💻",
-        "prompt": "You are an expert programmer. Write efficient, documented code."
-    },
-    "researcher": {
-        "name": "Researcher",
-        "icon": "🔬",
-        "prompt": "You are a researcher. Search the web and synthesize information."
-    },
-    "sysadmin": {
-        "name": "SysAdmin",
-        "icon": "⚙️",
-        "prompt": "You are a system administrator. Manage files, processes, and server health."
-    },
-    "creative": {
-        "name": "Creative",
-        "icon": "🎨",
-        "prompt": "You are a creative artist and writer."
-    },
-    "analyst": {
-        "name": "Analyst",
-        "icon": "📊",
-        "prompt": "You are a data analyst. Interpret data and metrics."
-    },
-    "security": {
-        "name": "Security",
-        "icon": "🛡️",
-        "prompt": "You are a security expert. Audit code and permissions."
-    },
-    "doctor": {
-        "name": "Doctor",
-        "icon": "🏥",
-        "prompt": "You are the health monitor."
-    },
-    "file_manager": {
-        "name": "FileManager",
-        "icon": "📁",
-        "prompt": "Organize and manage the file system."
+def tool_schema(name: str, desc: str, props: dict, required: Optional[list]=None):
+    return {
+        "type": "function",
+        "function": {
+            "name": name,
+            "description": desc,
+            "parameters": {"type": "object", "properties": props, "required": required or list(props.keys())}
+        }
     }
-}
 
-# Agent team list
-agent_team = list(AGENTS.values())
+TOOLS_SCHEMA = [
+    tool_schema("web_search", "Search the web (DuckDuckGo)", {"query":{"type":"string"}, "max_results":{"type":"integer","default":5}}, ["query"]),
+    tool_schema("read_webpage", "Fetch and extract readable webpage text", {"url":{"type":"string"}}, ["url"]),
+    tool_schema("calculator", "Math / symbolic calculation", {"expression":{"type":"string"}}, ["expression"]),
+    tool_schema("system_info", "CPU/RAM/Disk/Uptime", {}, []),
+    tool_schema("get_weather", "Weather for a city", {"city":{"type":"string"}, "units":{"type":"string","default":"metric"}}, ["city"]),
+    tool_schema("translate_text", "Translate text", {"text":{"type":"string"}, "target_language":{"type":"string"}}, ["text","target_language"]),
+    tool_schema("summarize_text", "Summarize text", {"text":{"type":"string"}, "style":{"type":"string","default":"bullets"}}, ["text"]),
+    tool_schema("memory_store", "Remember something long-term", {"text":{"type":"string"}}, ["text"]),
+    tool_schema("memory_search", "Search remembered info", {"query":{"type":"string"}}, ["query"]),
+    tool_schema("schedule_task", "Schedule future autonomous task", {"delay_seconds":{"type":"integer"}, "prompt":{"type":"string"}, "repeat_seconds":{"type":"integer","default":0}}, ["delay_seconds","prompt"]),
+    tool_schema("list_tasks", "List scheduled tasks", {}, []),
+    tool_schema("cancel_task", "Cancel a scheduled task", {"task_id":{"type":"integer"}}, ["task_id"]),
+    tool_schema("text_to_speech", "Generate speech audio (gTTS or OpenAI)", {"text":{"type":"string"}}, ["text"]),
+    tool_schema("analyze_image", "Analyze image (PIL metadata)", {"image_b64":{"type":"string"}, "prompt":{"type":"string","default":"Describe"}}, ["image_b64"]),
+
+    # admin-only dangerous:
+    tool_schema("execute_python", "Execute Python code", {"code":{"type":"string"}}, ["code"]),
+    tool_schema("run_shell", "Run a shell command", {"command":{"type":"string"}}, ["command"]),
+    tool_schema("file_read", "Read server file", {"path":{"type":"string"}}, ["path"]),
+    tool_schema("file_list", "List directory", {"path":{"type":"string","default":"."}}, []),
+    tool_schema("file_write", "Write server file", {"path":{"type":"string"}, "content":{"type":"string"}}, ["path","content"]),
+    tool_schema("file_delete", "Delete server file/dir", {"path":{"type":"string"}}, ["path"]),
+    tool_schema("install_package", "pip install package", {"package_name":{"type":"string"}}, ["package_name"]),
+    tool_schema("self_modify", "Edit bot source code", {"action":{"type":"string","enum":["read","edit","append","replace"]}, "file":{"type":"string"}, "content":{"type":"string"}, "find":{"type":"string"}, "replace_with":{"type":"string"}}, ["action","file"]),
+    tool_schema("http_request", "HTTP request", {"url":{"type":"string"}, "method":{"type":"string","default":"GET"}, "headers":{"type":"object"}, "body":{"type":"object"}}, ["url"]),
+    tool_schema("send_email", "Send email via SMTP", {"to":{"type":"string"}, "subject":{"type":"string