Update app/telegram_bot.py

app/telegram_bot.py

@@ -1,8 +1,8 @@
 """
-Telegram Bot — PraisonChat v4
-Handles: text, voice audio, images, files, code results
+Telegram Bot — PraisonChat v6
+Fixed: DNS error handling, env var fallback, robust connection
 """
-import os, json, asyncio, base64, traceback
+import os, json, asyncio, base64, traceback, socket
 import httpx
 import config as cfg
 
@@ -10,39 +10,49 @@ TELEGRAM_API = "https://api.telegram.org/bot{token}/{method}"
 _histories: dict = {}
 
 
-def _url(method: str) -> str:
+def _url(method):
     return TELEGRAM_API.format(token=cfg.get_telegram_token(), method=method)
 
 
-async def _post(method: str, **kwargs) -> dict:
-    async with httpx.AsyncClient(timeout=30) as c:
+def check_telegram_reachable() -> tuple[bool, str]:
+    """Check if api.telegram.org is reachable via DNS."""
+    try:
+        socket.setdefaulttimeout(5)
+        socket.gethostbyname("api.telegram.org")
+        return True, "OK"
+    except socket.gaierror as e:
+        return False, f"DNS error: api.telegram.org not reachable from this server. Error: {e}"
+    except Exception as e:
+        return False, str(e)
+
+
+async def _post(method, timeout=15, **kwargs):
+    async with httpx.AsyncClient(timeout=timeout) as c:
         r = await c.post(_url(method), **kwargs)
         return r.json()
 
 
-async def send_message(chat_id: int, text: str, parse_mode: str = "Markdown") -> bool:
-    if not text.strip(): return True
+async def send_message(chat_id, text, parse_mode="Markdown"):
+    if not text or not text.strip(): return True
     chunks = [text[i:i+3900] for i in range(0, len(text), 3900)]
     for chunk in chunks:
         try:
-            r = await _post("sendMessage",
-                json={"chat_id": chat_id, "text": chunk, "parse_mode": parse_mode})
+            r = await _post("sendMessage", json={"chat_id": chat_id, "text": chunk, "parse_mode": parse_mode})
             if not r.get("ok"):
                 await _post("sendMessage", json={"chat_id": chat_id, "text": chunk})
         except Exception as e:
-            print(f"[TG] send_message error: {e}")
+            print(f"[TG] send error: {e}")
     return True
 
 
-async def send_typing(chat_id: int):
+async def send_typing(chat_id):
     try:
-        await _post("sendChatAction",
-            json={"chat_id": chat_id, "action": "typing"})
+        await _post("sendChatAction", json={"chat_id": chat_id, "action": "typing"})
     except Exception:
         pass
 
 
-async def send_voice(chat_id: int, audio_b64: str) -> bool:
+async def send_voice(chat_id, audio_b64):
     try:
         audio_bytes = base64.b64decode(audio_b64)
         async with httpx.AsyncClient(timeout=60) as c:
@@ -51,25 +61,24 @@ async def send_voice(chat_id: int, audio_b64: str) -> bool:
                 data={"chat_id": str(chat_id)})
             return r.json().get("ok", False)
     except Exception as e:
-        print(f"[TG] send_voice error: {e}")
+        print(f"[TG] voice error: {e}")
         return False
 
 
-async def send_photo(chat_id: int, img_b64: str, filename: str, ext: str) -> bool:
+async def send_photo(chat_id, img_b64, filename, ext):
     try:
         img_bytes = base64.b64decode(img_b64)
-        mime = f"image/{ext}" if ext else "image/png"
         async with httpx.AsyncClient(timeout=30) as c:
             r = await c.post(_url("sendPhoto"),
-                files={"photo": (filename, img_bytes, mime)},
+                files={"photo": (filename, img_bytes, f"image/{ext}")},
                 data={"chat_id": str(chat_id), "caption": f"🖼️ {filename}"})
             return r.json().get("ok", False)
     except Exception as e:
-        print(f"[TG] send_photo error: {e}")
+        print(f"[TG] photo error: {e}")
         return False
 
 
-async def send_document(chat_id: int, file_b64: str, filename: str) -> bool:
+async def send_document(chat_id, file_b64, filename):
     try:
         file_bytes = base64.b64decode(file_b64)
         async with httpx.AsyncClient(timeout=60) as c:
@@ -78,58 +87,48 @@ async def send_document(chat_id: int, file_b64: str, filename: str) -> bool:
                 data={"chat_id": str(chat_id), "caption": f"📄 {filename}"})
             return r.json().get("ok", False)
     except Exception as e:
-        print(f"[TG] send_document error: {e}")
+        print(f"[TG] doc error: {e}")
         return False
 
 
-async def set_webhook(base_url: str) -> dict:
+async def set_webhook(base_url):
     url = base_url.rstrip("/") + "/telegram/webhook"
     return await _post("setWebhook",
         json={"url": url, "allowed_updates": ["message"], "drop_pending_updates": True})
 
 
-async def delete_webhook() -> dict:
+async def delete_webhook():
     return await _post("deleteWebhook", json={})
 
 
-async def get_bot_info() -> dict:
-    return await _post("getMe")
+async def get_bot_info():
+    return await _post("getMe", timeout=10)
 
 
-async def get_webhook_info() -> dict:
-    return await _post("getWebhookInfo")
+async def get_webhook_info():
+    return await _post("getWebhookInfo", timeout=10)
 
 
-async def handle_update(update: dict, api_key: str, model: str):
+async def handle_update(update, api_key, model):
     from agent_system import orchestrator
 
     msg = update.get("message") or update.get("edited_message")
-    if not msg:
-        return
+    if not msg: return
 
     chat_id  = msg["chat"]["id"]
-    text     = msg.get("text", "").strip()
-    username = msg.get("from", {}).get("first_name", "User")
+    text     = msg.get("text","").strip()
+    username = msg.get("from",{}).get("first_name","User")
 
-    if not text:
-        return
-
-    print(f"[TG] {username} ({chat_id}): {text[:80]}")
+    if not text: return
+    print(f"[TG] {username} ({chat_id}): {text[:60]}")
 
     # Commands
     if text == "/start":
         await send_message(chat_id,
-            f"👋 Hello {username}! I'm *PraisonChat* 🐱\n\n"
-            "I have a real Python interpreter — I write code to solve your tasks:\n"
-            "🔍 Real web search (DuckDuckGo)\n"
-            "🕐 Real date & time\n"
-            "🐍 Real code execution\n"
-            "📦 Auto-install any Python package\n"
-            "🔊 Voice audio generation\n"
-            "🖼️ Image generation/processing\n"
-            "📄 File creation & download\n\n"
-            "Just type anything — I'll write code to make it happen!\n\n"
-            "/clear - Clear history | /help - Help")
+            f"👋 Hello {username}! I'm *PraisonChat* 🦞\n\n"
+            "I'm an autonomous AI agent with real code execution.\n\n"
+            "Commands: /clear /help /status\n\n"
+            "Just type anything!")
         return
 
     if text == "/clear":
@@ -137,29 +136,31 @@ async def handle_update(update: dict, api_key: str, model: str):
         await send_message(chat_id, "✅ History cleared!")
         return
 
+    if text == "/status":
+        await send_message(chat_id,
+            f"✅ Online\nModel: `{model}`\n"
+            f"API: `{'set ✅' if api_key else 'missing ❌'}`")
+        return
+
     if text == "/help":
         await send_message(chat_id,
-            "🤖 *Try these:*\n"
-            "• `What time is it?`\n"
-            "• `Search for latest AI news`\n"
-            "• `Create a QR code for https://example.com`\n"
-            "• `Plot a bar chart of population by continent`\n"
-            "• `Say hello in voice`\n"
-            "• `Write a Python script to generate a password`\n"
-            "• `Fetch the weather in London`\n\n"
-            "I write *real Python code* and execute it — not simulated!")
+            "*PraisonChat* can:\n"
+            "• 🔍 Search the web in real-time\n"
+            "• 🕐 Tell you date and time\n"
+            "• 🐍 Execute Python code\n"
+            "• 🔊 Generate voice audio\n"
+            "• 📊 Create charts and images\n"
+            "• 🤖 Spawn sub-agents\n\n"
+            "Try: `What time is it?` or `Search for latest AI news`")
         return
 
-    # Immediate ack
     await send_typing(chat_id)
-    await send_message(chat_id, "⏳ On it…")
+    await send_message(chat_id, "⏳ Working on it…")
 
-    history      = _histories.get(chat_id, [])
+    history       = _histories.get(chat_id, [])
     full_response = ""
     audio_b64     = None
     has_media     = False
-    activity_msgs = []
-    code_outputs  = []
 
     try:
         async for chunk_json in orchestrator.stream_response(text, history, api_key, model):
@@ -168,106 +169,56 @@ async def handle_update(update: dict, api_key: str, model: str):
             except Exception:
                 continue
 
-            t = ev.get("type", "")
-
-            if t == "thinking":
-                pass
-
-            elif t == "code_executing":
-                idx = ev.get("index", 0)
-                activity_msgs.append(f"🐍 Running code block {idx+1}…")
-
-            elif t == "code_result":
-                stdout = ev.get("stdout", "").strip()
-                ok     = ev.get("ok", False)
-                if stdout and len(stdout) < 400:
-                    code_outputs.append(f"{'✅' if ok else '❌'} ```\n{stdout}\n```")
-                elif not ok:
-                    stderr = ev.get("stderr","")[:200]
-                    code_outputs.append(f"❌ Error: `{stderr}`")
-
-            elif t == "pkg_install":
-                pkg = ev.get("package", "")
-                ok  = ev.get("ok", False)
-                if pkg:
-                    activity_msgs.append(f"{'📦✅' if ok else '📦❌'} `{pkg}`")
-
-            elif t == "agent_created":
-                activity_msgs.append(f"🤖 Agent: *{ev.get('name','')}*")
-
-            elif t == "token":
-                full_response += ev.get("content", "")
+            t = ev.get("type","")
 
+            if t == "token":
+                full_response += ev.get("content","")
             elif t == "audio_response":
                 audio_b64 = ev.get("audio_b64")
-                has_media  = True
-
+                has_media = True
             elif t == "image_response":
-                img_b64  = ev.get("image_b64", "")
-                filename = ev.get("filename", "image.png")
-                ext      = ev.get("ext", "png")
+                img_b64  = ev.get("image_b64","")
+                filename = ev.get("filename","image.png")
+                ext      = ev.get("ext","png")
                 if img_b64:
                     await send_typing(chat_id)
                     await send_photo(chat_id, img_b64, filename, ext)
                     has_media = True
-
             elif t == "file_response":
-                file_b64 = ev.get("file_b64", "")
-                filename = ev.get("filename", "file")
+                file_b64 = ev.get("file_b64","")
+                filename = ev.get("filename","file")
                 if file_b64:
                     await send_typing(chat_id)
                     await send_document(chat_id, file_b64, filename)
                     has_media = True
-
-            elif t == "voice_fallback":
-                vtext = ev.get("text", "")
-                if vtext:
-                    full_response += f"\n\n🔊 _{vtext[:300]}_"
-
             elif t == "error":
-                err = ev.get("message", "unknown")
-                print(f"[TG] Error: {err}")
-                await send_message(chat_id, f"❌ Error: {err[:300]}")
+                await send_message(chat_id, f"❌ {ev.get('message','Error')[:300]}")
                 return
 
     except Exception as e:
-        print(f"[TG] Exception: {e}\n{traceback.format_exc()}")
+        print(f"[TG] exception: {e}\n{traceback.format_exc()}")
         await send_message(chat_id, f"❌ Error: {str(e)[:200]}")
         return
 
-    # Send activity summary
-    if activity_msgs:
-        await send_message(chat_id, "\n".join(activity_msgs[:6]))
-
-    # Send code outputs if short
-    if code_outputs and not full_response:
-        await send_message(chat_id, "\n\n".join(code_outputs[:3]))
-
-    # Send main text response
+    # Send text response
     clean = (full_response
              .replace("**","*")
-             .replace("<execute>","```python\n")
-             .replace("</execute>","\n```")
-             .replace("[VOICE:","").strip())
-    # Remove VOICE] tags
+             .replace("[SPEAK:","").replace("]",""))
     import re
-    clean = re.sub(r'\[VOICE:.*?\]', '', clean, flags=re.DOTALL).strip()
+    clean = re.sub(r'<[^>]+>.*?</[^>]+>', '', clean, flags=re.DOTALL).strip()
 
     if clean:
         await send_message(chat_id, clean)
-    elif not has_media and not code_outputs:
-        await send_message(chat_id, "_(Processing complete — no text output)_")
+    elif not has_media:
+        await send_message(chat_id, "_(Done — no text output)_")
 
-    # Send voice
     if audio_b64:
         await send_typing(chat_id)
-        ok = await send_voice(chat_id, audio_b64)
-        if not ok:
-            await send_message(chat_id, "⚠️ Could not send voice file")
+        await send_voice(chat_id, audio_b64)
 
     # Update history
-    history.append({"role": "user",      "content": text})
-    history.append({"role": "assistant", "content": full_response or "(media response)"})
+    history.append({"role":"user","content":text})
+    history.append({"role":"assistant","content":full_response or "(media)"})
     _histories[chat_id] = history[-24:]
 
-    print(f"[TG] Done: {username} ({chat_id}), {len(full_response)} chars")
+    print(f"[TG] Replied to {username}: {len(full_response)} chars")