Update app/agent_system.py

app/agent_system.py

@@ -1,19 +1,17 @@
 """
-PraisonChat Agent System v5 — OpenClaw-style
-=============================================
-- Code interpreter loop (write → execute → reflect → repeat)
-- Persistent memory + skills
-- Real sub-agents with real tool execution
-- Clean output: only results shown, internals hidden
-- Robust JSON error handling
+PraisonChat Agent System v6 — Reliable
+=======================================
+- Fast path for simple messages (no code execution overhead)
+- Agentic loop only for tasks that need it
+- Never silent failures — always emits response
 """
 import os, json, asyncio, datetime, traceback, re
 from openai import AsyncOpenAI
 from sandbox import run as sandbox_run, pip_install, PKG_DIR
 from docs_context import PRAISONAI_DOCS
 from memory import (
-    get_memory_context, get_skills_context, save_memory,
-    save_skill, list_skills, search_memories
+    get_memory_context, get_skills_context,
+    save_memory, save_skill, search_memories
 )
 
 LONGCAT_BASE = "https://api.longcat.chat/openai/v1"
@@ -25,338 +23,319 @@ MODEL_MAP = {
 DEFAULT_MODEL = "LongCat-Flash-Lite"
 
 def now_str():
-    return datetime.datetime.now().strftime("%A, %B %d %Y at %I:%M:%S %p")
-
-def build_system(memory_ctx: str, skills_ctx: str) -> str:
-    return f"""You are PraisonChat — a powerful autonomous AI agent.
-You have a real Python code interpreter, persistent memory, and can create/save reusable skills.
-
-Current datetime: {now_str()}
+    return datetime.datetime.now().strftime("%A, %B %d %Y %I:%M:%S %p")
+
+# ── Detect if a task needs code execution ──────────────────────────────────
+NEEDS_CODE_KEYWORDS = [
+    "search", "find", "look up", "lookup", "browse", "web",
+    "time", "date", "today", "weather", "news", "latest",
+    "calculate", "math", "compute", "solve",
+    "create", "make", "generate", "build", "draw", "plot", "chart", "graph",
+    "image", "picture", "photo", "qr code", "qr",
+    "voice", "audio", "speak", "say", "read aloud",
+    "code", "script", "python", "run", "execute",
+    "file", "pdf", "download", "save",
+    "fetch", "scrape", "extract", "parse",
+    "install", "pip",
+    "agent", "sub-agent", "spawn",
+    "memory", "remember", "recall",
+    "skill", "tool",
+]
+
+def needs_code(msg: str) -> bool:
+    m = msg.lower()
+    return any(kw in m for kw in NEEDS_CODE_KEYWORDS)
+
+
+SIMPLE_SYSTEM = """You are PraisonChat — a helpful, intelligent AI assistant.
+Current datetime: {DATETIME}
+Be concise, friendly, and helpful. Use markdown for formatting when useful."""
+
+AGENT_SYSTEM = f"""You are PraisonChat — a powerful autonomous AI agent with a real Python interpreter.
+Current datetime: {{DATETIME}}
 Python packages dir: {PKG_DIR}
 
-{memory_ctx}
+## MEMORY
+{{MEMORY}}
 
-{skills_ctx}
+## AVAILABLE SKILLS  
+{{SKILLS}}
 
 ## CODE INTERPRETER
-Write Python inside <execute> tags. It runs IMMEDIATELY with real results.
+Write Python in <execute> tags — it runs with REAL results immediately.
+Always add: import sys; sys.path.insert(0, '{PKG_DIR}')
 
-Rules:
-- ALWAYS import sys and add PKG_DIR to path: sys.path.insert(0, '{PKG_DIR}')
-- Use duckduckgo_search for web searches (NOT google.com)
-- Save files (images, audio, PDFs) to current dir — they are returned to user
-- Use gtts for voice/audio generation
-- For voice: save as voice_response.mp3, it becomes a playable audio
-- For images: save as image.png, it becomes visible in chat
-- NEVER simulate or estimate data — always execute real code
+Examples:
+<execute>
+import sys, datetime
+sys.path.insert(0, '{PKG_DIR}')
+print(datetime.datetime.now().strftime("%A, %B %d %Y %I:%M:%S %p"))
+</execute>
 
-## MEMORY SYSTEM
-Save important info:
-<save_memory key="user_preferences">User prefers dark mode, speaks English</save_memory>
+<execute>
+import sys
+sys.path.insert(0, '{PKG_DIR}')
+from duckduckgo_search import DDGS
+with DDGS() as d:
+    for r in d.text("latest AI news 2025", max_results=4):
+        print(r['title'], '-', r['body'][:100])
+</execute>
 
-Search memory:
+## MEMORY SYSTEM
+<save_memory key="user_name">John</save_memory>
 <search_memory>user preferences</search_memory>
 
-## SKILLS SYSTEM  
-Save reusable code as a skill:
-<save_skill name="search_news" description="Search for latest news using DuckDuckGo">
+## SKILLS SYSTEM
+<save_skill name="search_web" description="Search DuckDuckGo">
 import sys
 sys.path.insert(0, '{PKG_DIR}')
-def search_news(query, max_results=5):
+def search_web(query, n=5):
     from duckduckgo_search import DDGS
-    with DDGS() as ddgs:
-        return list(ddgs.news(query, max_results=max_results))
+    with DDGS() as d:
+        return list(d.text(query, max_results=n))
 </save_skill>
 
 ## SUB-AGENTS
-For complex tasks, spawn specialized sub-agents:
-<spawn_agent name="ResearchAgent" task="Find the top 5 AI papers from 2025">
+<spawn_agent name="Researcher" task="Find AI news">
 import sys
 sys.path.insert(0, '{PKG_DIR}')
 from duckduckgo_search import DDGS
-results = []
-with DDGS() as ddgs:
-    for r in ddgs.text("top AI research papers 2025", max_results=8):
-        results.append(r['title'] + ': ' + r['body'])
-print('\n'.join(results))
+with DDGS() as d:
+    for r in d.text("AI news 2025", max_results=5):
+        print(r['title'])
 </spawn_agent>
 
-Each <spawn_agent> executes its code independently and returns real results.
-
-## RESPONSE FORMAT RULES
-- NEVER show raw code to the user in your final response
-- NEVER say "I executed the following code..."
-- JUST present the RESULTS clearly
-- Use markdown for formatting
-- For voice requests: put the text to speak in [SPEAK: text here]
-- For math: just show the answer
-- For search: show results in a clean list
+## OUTPUT RULES
+- NEVER show <execute> tags or code in the final response
+- Present only clean results to the user
+- Use markdown formatting
+- For voice: put text in [SPEAK: your text here]
+- For images/audio/files: they are automatically sent
 
-## AVAILABLE PACKAGES (always installed)
+## PRE-INSTALLED PACKAGES
 requests, httpx, duckduckgo-search, beautifulsoup4, gtts, pillow,
 matplotlib, numpy, pandas, qrcode, python-dateutil, pytz
 
-## ADDITIONAL PACKAGES
-Just import any package — it gets auto-installed automatically.
-
 {PRAISONAI_DOCS}
 """
 
-def extract_blocks(text: str, tag: str) -> list[dict]:
-    """Extract all <tag ...>content</tag> blocks."""
+def get_agent_system(memory_ctx, skills_ctx):
+    return AGENT_SYSTEM.replace("{DATETIME}", now_str())\
+                       .replace("{MEMORY}", memory_ctx or "No memories yet.")\
+                       .replace("{SKILLS}", skills_ctx or "No skills yet.")
+
+def extract_blocks(text, tag):
     results = []
     pattern = rf'<{tag}([^>]*)>(.*?)</{tag}>'
     for m in re.finditer(pattern, text, re.DOTALL):
-        attrs_str = m.group(1).strip()
-        content   = m.group(2).strip()
-        # Parse key=value attrs
         attrs = {}
-        for a in re.finditer(r'(\w+)=["\']([^"\']*)["\']', attrs_str):
+        for a in re.finditer(r'(\w+)=["\']([^"\']*)["\']', m.group(1)):
             attrs[a.group(1)] = a.group(2)
-        results.append({"attrs": attrs, "content": content, "full": m.group(0)})
+        results.append({"attrs": attrs, "content": m.group(2).strip()})
     return results
 
-def strip_all_tags(text: str) -> str:
-    """Remove all agent internal tags from final response."""
-    tags = ["execute", "spawn_agent", "save_memory", "search_memory", "save_skill"]
-    for tag in tags:
+def strip_tags(text):
+    for tag in ["execute","spawn_agent","save_memory","search_memory","save_skill"]:
         text = re.sub(rf'<{tag}[^>]*>.*?</{tag}>', '', text, flags=re.DOTALL)
-    return text.strip()
+    return re.sub(r'\[SPEAK:.*?\]', '', text, flags=re.DOTALL).strip()
 
 
 class AgentOrchestrator:
     def __init__(self):
-        self._clients: dict = {}
+        self._clients = {}
 
-    def client(self, api_key: str) -> AsyncOpenAI:
+    def client(self, api_key):
         if api_key not in self._clients:
             self._clients[api_key] = AsyncOpenAI(
                 api_key=api_key, base_url=LONGCAT_BASE
             )
         return self._clients[api_key]
 
-    async def _llm(self, client, messages: list, model: str, stream: bool = False):
-        return await client.chat.completions.create(
-            model=model, messages=messages,
-            max_tokens=16000, temperature=0.7, stream=stream
-        )
-
-    async def stream_response(self, user_msg: str, history: list,
-                               api_key: str, model: str = DEFAULT_MODEL):
-        def emit(d: dict) -> str:
-            return json.dumps(d)
-
+    async def stream_response(self, user_msg, history, api_key, model=DEFAULT_MODEL):
+        def emit(d): return json.dumps(d)
         model = MODEL_MAP.get(model, DEFAULT_MODEL)
         cl    = self.client(api_key)
 
-        mem_ctx    = get_memory_context()
-        skills_ctx = get_skills_context()
+        try:
+            # ── FAST PATH: simple conversation (no code needed) ───────────
+            if not needs_code(user_msg):
+                yield emit({"type": "thinking", "text": "Responding…"})
+                await asyncio.sleep(0)
 
-        messages = [{"role": "system", "content": build_system(mem_ctx, skills_ctx)}]
-        for m in history[-14:]:
-            messages.append({"role": m["role"],
-                             "content": str(m.get("content",""))[:3000]})
-        messages.append({"role": "user", "content": user_msg})
+                messages = [{"role": "system", "content": SIMPLE_SYSTEM.replace("{DATETIME}", now_str())}]
+                for m in history[-12:]:
+                    messages.append({"role": m["role"], "content": str(m.get("content",""))[:2000]})
+                messages.append({"role": "user", "content": user_msg})
 
-        try:
-            MAX_ITER = 7
-            all_exec_results  = {}
-            all_agent_results = {}
+                yield emit({"type": "response_start"})
+                stream = await cl.chat.completions.create(
+                    model=model, messages=messages,
+                    max_tokens=4000, temperature=0.7, stream=True
+                )
+                async for chunk in stream:
+                    c = chunk.choices[0].delta.content
+                    if c:
+                        yield emit({"type": "token", "content": c})
+
+                yield emit({"type": "done"})
+                return
+
+            # ── AGENT PATH: task needs code execution ─────────────────────
+            mem_ctx    = get_memory_context()
+            skills_ctx = get_skills_context()
+
+            messages = [{"role": "system", "content": get_agent_system(mem_ctx, skills_ctx)}]
+            for m in history[-12:]:
+                messages.append({"role": m["role"], "content": str(m.get("content",""))[:2000]})
+            messages.append({"role": "user", "content": user_msg})
+
+            MAX_ITER = 5
+            all_results = {}
 
             for iteration in range(MAX_ITER):
-                yield emit({"type": "thinking",
-                            "text": f"Working… (step {iteration+1})"})
+                yield emit({"type": "thinking", "text": f"Working… (step {iteration+1})"})
                 await asyncio.sleep(0)
 
-                # ── LLM call ──────────────────────────────────────────────
-                resp = await self._llm(cl, messages, model)
-                raw  = resp.choices[0].message.content or ""
+                resp = await cl.chat.completions.create(
+                    model=model, messages=messages,
+                    max_tokens=8000, temperature=0.7
+                )
+                raw = resp.choices[0].message.content or ""
 
-                # ── Process special tags ──────────────────────────────────
-
-                # 1. Memory saves
+                # Process memory ops
                 for blk in extract_blocks(raw, "save_memory"):
-                    key     = blk["attrs"].get("key", f"note_{iteration}")
-                    content = blk["content"]
-                    save_memory(key, content)
+                    key = blk["attrs"].get("key", f"note_{iteration}")
+                    save_memory(key, blk["content"])
                     yield emit({"type": "memory_saved", "key": key})
 
-                # 2. Memory searches
                 for blk in extract_blocks(raw, "search_memory"):
-                    query  = blk["content"]
-                    result = search_memories(query)
-                    all_exec_results[f"memory:{query}"] = result
-                    yield emit({"type": "memory_search", "query": query,
-                                "result": result[:200]})
+                    result = search_memories(blk["content"])
+                    all_results[f"mem:{blk['content']}"] = result
 
-                # 3. Skill saves
+                # Process skill saves
                 for blk in extract_blocks(raw, "save_skill"):
                     name = blk["attrs"].get("name", f"skill_{iteration}")
-                    desc = blk["attrs"].get("description", "")
+                    desc = blk["attrs"].get("description","")
                     save_skill(name, blk["content"], desc)
-                    yield emit({"type": "skill_saved", "name": name,
-                                "description": desc})
+                    yield emit({"type": "skill_saved", "name": name, "description": desc})
+
+                # Process code blocks
+                exec_blocks   = extract_blocks(raw, "execute")
+                agent_blocks  = extract_blocks(raw, "spawn_agent")
+                has_actions   = bool(exec_blocks or agent_blocks or
+                                     extract_blocks(raw,"save_memory") or
+                                     extract_blocks(raw,"search_memory") or
+                                     extract_blocks(raw,"save_skill"))
 
-                # 4. Execute code blocks
-                exec_blocks = extract_blocks(raw, "execute")
                 for idx, blk in enumerate(exec_blocks):
-                    code = blk["content"]
                     yield emit({"type": "executing", "index": idx})
                     await asyncio.sleep(0)
-
                     loop   = asyncio.get_event_loop()
                     result = await loop.run_in_executor(
-                        None, lambda c=code: sandbox_run(c, max_retries=3, timeout=60)
+                        None, lambda c=blk["content"]: sandbox_run(c, max_retries=3, timeout=60)
                     )
-
-                    # Emit installs silently (activity panel only)
-                    for inst in result.get("installs", []):
-                        yield emit({"type": "pkg_install",
-                                    "package": inst["package"],
-                                    "ok": inst["ok"]})
-
-                    key     = f"code_{iteration}_{idx}"
-                    stdout  = result.get("stdout","").strip()
-                    stderr  = result.get("stderr","").strip()
-                    ok      = result.get("ok", False)
-                    files   = result.get("files", [])
-
-                    # Emit output files (audio, images, downloads)
+                    for inst in result.get("installs",[]):
+                        yield emit({"type":"pkg_install","package":inst["package"],"ok":inst["ok"]})
+                    stdout = result.get("stdout","").strip()
+                    stderr = result.get("stderr","").strip()
+                    ok     = result.get("ok", False)
+                    files  = result.get("files", [])
                     for f in files:
-                        ext   = f.get("ext","").lower()
-                        fname = f["name"]
-                        b64   = f["b64"]
+                        ext = f.get("ext","").lower()
+                        b64 = f["b64"]
                         if ext in {"mp3","wav","ogg","m4a"}:
-                            yield emit({"type":"audio_response",
-                                        "audio_b64":b64, "filename":fname})
+                            yield emit({"type":"audio_response","audio_b64":b64,"filename":f["name"]})
                         elif ext in {"png","jpg","jpeg","gif","webp","svg"}:
-                            yield emit({"type":"image_response",
-                                        "image_b64":b64, "filename":fname, "ext":ext})
+                            yield emit({"type":"image_response","image_b64":b64,"filename":f["name"],"ext":ext})
                         else:
-                            yield emit({"type":"file_response",
-                                        "file_b64":b64, "filename":fname,
-                                        "size":f.get("size",0)})
-
-                    exec_result = stdout if ok else f"Error: {stderr}"
-                    all_exec_results[key] = exec_result
-
-                    yield emit({"type": "exec_done",
-                                "ok":     ok,
-                                "output": exec_result[:300],
-                                "files":  [f["name"] for f in files]})
+                            yield emit({"type":"file_response","file_b64":b64,"filename":f["name"],"size":f.get("size",0)})
+                    out_txt = stdout if ok else f"Error: {stderr}"
+                    all_results[f"code_{iteration}_{idx}"] = out_txt
+                    yield emit({"type":"exec_done","ok":ok,"output":out_txt[:300],"files":[f["name"] for f in files]})
 
-                # 5. Spawn sub-agents
-                agent_blocks = extract_blocks(raw, "spawn_agent")
                 for blk in agent_blocks:
                     name = blk["attrs"].get("name", f"Agent_{iteration}")
-                    task = blk["attrs"].get("task", "Execute task")
-                    code = blk["content"]
-
+                    task = blk["attrs"].get("task","")
                     yield emit({"type":"agent_created","name":name,"task":task[:100]})
-                    await asyncio.sleep(0)
-
                     yield emit({"type":"agent_working","name":name})
-
                     loop   = asyncio.get_event_loop()
                     result = await loop.run_in_executor(
-                        None, lambda c=code: sandbox_run(c, max_retries=3, timeout=90)
+                        None, lambda c=blk["content"]: sandbox_run(c, max_retries=3, timeout=90)
                     )
-
-                    for inst in result.get("installs", []):
-                        yield emit({"type":"pkg_install",
-                                    "package":inst["package"],"ok":inst["ok"]})
-
+                    for inst in result.get("installs",[]):
+                        yield emit({"type":"pkg_install","package":inst["package"],"ok":inst["ok"]})
                     stdout = result.get("stdout","").strip()
-                    stderr = result.get("stderr","").strip()
                     ok     = result.get("ok", False)
-                    files  = result.get("files", [])
-
+                    files  = result.get("files",[])
                     for f in files:
-                        ext = f.get("ext","").lower()
-                        b64 = f["b64"]
+                        ext=f.get("ext","").lower();b64=f["b64"]
                         if ext in {"mp3","wav","ogg"}:
                             yield emit({"type":"audio_response","audio_b64":b64,"filename":f["name"]})
                         elif ext in {"png","jpg","jpeg","gif","webp"}:
                             yield emit({"type":"image_response","image_b64":b64,"filename":f["name"],"ext":ext})
                         else:
                             yield emit({"type":"file_response","file_b64":b64,"filename":f["name"],"size":f.get("size",0)})
+                    out_txt = stdout if ok else f"Error: {result.get('stderr','')}"
+                    all_results[name] = out_txt
+                    yield emit({"type":"agent_done","name":name,"preview":out_txt[:250],"ok":ok})
 
-                    agent_out = stdout if ok else f"Error: {stderr}"
-                    all_agent_results[name] = agent_out
-
-                    yield emit({"type":"agent_done","name":name,
-                                "preview":agent_out[:250],"ok":ok})
-
-                # ── Decide: done or iterate? ──────────────────────────────
-                has_actions = (exec_blocks or agent_blocks or
-                               extract_blocks(raw, "save_memory") or
-                               extract_blocks(raw, "search_memory") or
-                               extract_blocks(raw, "save_skill"))
-
+                # ── Decide: done or iterate ──────────────────────────────
                 if not has_actions:
-                    # Pure text response — strip tags and stream it
-                    clean = strip_all_tags(raw)
-                    yield emit({"type":"response_start"})
+                    # Final clean response
+                    clean = strip_tags(raw)
+                    if not clean.strip():
+                        clean = "Done! Let me know if you need anything else."
 
-                    # Stream character by character for smooth effect
-                    chunk_size = 8
+                    yield emit({"type": "response_start"})
+                    chunk_size = 6
                     for i in range(0, len(clean), chunk_size):
-                        yield emit({"type":"token","content":clean[i:i+chunk_size]})
-                        if i % 80 == 0:
-                            await asyncio.sleep(0)
+                        yield emit({"type": "token", "content": clean[i:i+chunk_size]})
+                        if i % 60 == 0: await asyncio.sleep(0)
 
                     # Handle voice
-                    if "[SPEAK:" in clean:
+                    if "[SPEAK:" in raw:
                         try:
-                            speak_text = clean.split("[SPEAK:")[1].rsplit("]",1)[0].strip()
+                            speak_text = raw.split("[SPEAK:")[1].rsplit("]",1)[0].strip()
                             voice_code = f"""
 import sys, io, base64
 sys.path.insert(0, '{PKG_DIR}')
 from gtts import gTTS
 tts = gTTS(text={repr(speak_text[:2000])}, lang='en', slow=False)
 tts.save('voice_response.mp3')
-print('Voice generated')
+print('ok')
 """
-                            loop   = asyncio.get_event_loop()
-                            vr     = await loop.run_in_executor(
+                            loop = asyncio.get_event_loop()
+                            vr   = await loop.run_in_executor(
                                 None, lambda: sandbox_run(voice_code, timeout=30)
                             )
-                            for f in vr.get("files", []):
-                                if f.get("ext") == "mp3":
-                                    yield emit({"type":"audio_response",
-                                                "audio_b64":f["b64"],
-                                                "filename":"voice_response.mp3"})
+                            for f in vr.get("files",[]):
+                                if f.get("ext")=="mp3":
+                                    yield emit({"type":"audio_response","audio_b64":f["b64"],"filename":"voice_response.mp3"})
                         except Exception:
                             pass
-
                     break
 
                 else:
-                    # Feed results back to LLM for next iteration
-                    results_summary = ""
-                    if all_exec_results:
-                        results_summary += "EXECUTION RESULTS:\n"
-                        for k, v in list(all_exec_results.items())[-5:]:
-                            results_summary += f"[{k}]: {v[:800]}\n\n"
-                    if all_agent_results:
-                        results_summary += "AGENT RESULTS:\n"
-                        for name, out in all_agent_results.items():
-                            results_summary += f"[{name}]: {out[:800]}\n\n"
-
-                    messages.append({"role":"assistant","content":raw})
-                    messages.append({"role":"user","content":(
-                        f"{results_summary}\n"
-                        f"Now give the user a clean, clear response based on these REAL results. "
-                        f"Do NOT show code. Do NOT show <execute> tags. "
-                        f"Just present the results/answer naturally in markdown."
+                    # Feed results back
+                    results_text = "REAL EXECUTION RESULTS:\n\n"
+                    for k, v in list(all_results.items())[-4:]:
+                        results_text += f"[{k}]:\n{v[:1000]}\n\n"
+                    messages.append({"role": "assistant", "content": raw})
+                    messages.append({"role": "user", "content": (
+                        f"{results_text}"
+                        f"Now give the user a clean final answer based on these REAL results. "
+                        f"Do NOT use <execute> tags. Do NOT show code. Just present the results clearly in markdown."
                     )})
 
-            yield emit({"type":"done"})
+            yield emit({"type": "done"})
 
         except Exception as e:
             tb = traceback.format_exc()
-            print(f"[AGENT] Error: {e}\n{tb}")
-            yield emit({"type":"error","message":str(e),"detail":tb[-600:]})
+            print(f"[AGENT] {e}\n{tb}")
+            # Always emit a response so the user sees something
+            yield emit({"type": "response_start"})
+            yield emit({"type": "token", "content": f"❌ Error: {str(e)}\n\nPlease check your LongCat API key in Settings."})
+            yield emit({"type": "done"})
 
 
 orchestrator = AgentOrchestrator()