Update app/agent_system.py

app/agent_system.py

@@ -1,14 +1,20 @@
 """
-PraisonChat — Code Interpreter Agent
-======================================
-Like ClawBot: the AI writes real Python, we execute it, AI sees real output,
-AI iterates. No fake tools. No simulation. Everything is real.
+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
 """
-import os, json, asyncio, datetime, traceback, base64, re
+import os, json, asyncio, datetime, traceback, re
 from openai import AsyncOpenAI
-from typing import AsyncGenerator
 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
+)
 
 LONGCAT_BASE = "https://api.longcat.chat/openai/v1"
 MODEL_MAP = {
@@ -18,79 +24,104 @@ MODEL_MAP = {
 }
 DEFAULT_MODEL = "LongCat-Flash-Lite"
 
-def now_iso():
-    return datetime.datetime.now().strftime("%A %B %d %Y %I:%M:%S %p")
+def now_str():
+    return datetime.datetime.now().strftime("%A, %B %d %Y at %I:%M:%S %p")
 
-# ─── Master system prompt ────────────────────────────────────────────────────
-SYSTEM = f"""You are PraisonChat — a powerful AI assistant with a real Python code interpreter.
-You can write and execute Python code to accomplish ANY task.
+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: {{DATETIME}}
-Python package dir: {PKG_DIR}
+Current datetime: {now_str()}
+Python packages dir: {PKG_DIR}
 
-## HOW TO USE THE CODE INTERPRETER
+{memory_ctx}
 
-When you need to do ANYTHING real (search, calculate, fetch data, generate audio, create files,
-draw charts, etc.) — write Python code inside <execute> tags:
+{skills_ctx}
 
-<execute>
-# Example: search the web
+## CODE INTERPRETER
+Write Python inside <execute> tags. It runs IMMEDIATELY with real results.
+
+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
+
+## MEMORY SYSTEM
+Save important info:
+<save_memory key="user_preferences">User prefers dark mode, speaks English</save_memory>
+
+Search 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">
+import sys
+sys.path.insert(0, '{PKG_DIR}')
+def search_news(query, max_results=5):
+    from duckduckgo_search import DDGS
+    with DDGS() as ddgs:
+        return list(ddgs.news(query, max_results=max_results))
+</save_skill>
+
+## SUB-AGENTS
+For complex tasks, spawn specialized sub-agents:
+<spawn_agent name="ResearchAgent" task="Find the top 5 AI papers from 2025">
 import sys
 sys.path.insert(0, '{PKG_DIR}')
 from duckduckgo_search import DDGS
-
+results = []
 with DDGS() as ddgs:
-    results = list(ddgs.text("latest AI news 2025", max_results=5))
-    for r in results:
-        print(r['title'])
-        print(r['body'])
-        print()
-</execute>
-
-The code runs IMMEDIATELY in a real Python environment.
-You will see the ACTUAL output and can write more code based on it.
-
-## RULES
-1. ALWAYS use <execute> for: web search, date/time, calculations, file creation, audio, images
-2. Never say "I cannot" — instead write code that does it
-3. If a library is missing, just import it — it gets auto-installed
-4. To generate VOICE: use gtts and save as .mp3, then it gets returned as audio
-5. To create FILES (images, PDFs, etc.): save to current dir, they get returned automatically
-6. You can pip install ANYTHING: just `import subprocess; subprocess.run(["pip","install","X"])`
-   OR just import it directly — auto-install handles it
-7. Chain multiple <execute> blocks if needed
-8. After seeing results, explain them clearly to the user
-
-## AVAILABLE PRE-INSTALLED PACKAGES
-requests, httpx, beautifulsoup4, duckduckgo-search, gtts, pillow, matplotlib,
-numpy, pandas, qrcode, python-dateutil, pytz
-
-## RESPONSE FORMATS
-- For voice/audio requests: save MP3 to file, it will be sent as audio
-- For image requests: save PNG/JPG, it will be displayed
-- For data: print clearly formatted output
-- For files: save to current directory, they get returned
+    for r in ddgs.text("top AI research papers 2025", max_results=8):
+        results.append(r['title'] + ': ' + r['body'])
+print('\n'.join(results))
+</spawn_agent>
 
-{PRAISONAI_DOCS}
-"""
+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
 
-def get_system():
-    return SYSTEM.replace("{DATETIME}", now_iso())
+## AVAILABLE PACKAGES (always installed)
+requests, httpx, duckduckgo-search, beautifulsoup4, gtts, pillow,
+matplotlib, numpy, pandas, qrcode, python-dateutil, pytz
 
-# ─── Parse <execute> blocks from LLM response ────────────────────────────────
-def extract_code_blocks(text: str) -> list[str]:
-    return re.findall(r'<execute>(.*?)</execute>', text, re.DOTALL)
+## ADDITIONAL PACKAGES
+Just import any package — it gets auto-installed automatically.
 
-def strip_code_blocks(text: str) -> str:
-    return re.sub(r'<execute>.*?</execute>', '', text, flags=re.DOTALL).strip()
+{PRAISONAI_DOCS}
+"""
 
-# ─── Detect output type from files ───────────────────────────────────────────
-def classify_file(name: str, ext: str) -> str:
-    audio_exts = {"mp3","wav","ogg","m4a","flac","aac"}
-    image_exts = {"png","jpg","jpeg","gif","webp","bmp","svg"}
-    if ext in audio_exts: return "audio"
-    if ext in image_exts: return "image"
-    return "file"
+def extract_blocks(text: str, tag: str) -> list[dict]:
+    """Extract all <tag ...>content</tag> blocks."""
+    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):
+            attrs[a.group(1)] = a.group(2)
+        results.append({"attrs": attrs, "content": content, "full": m.group(0)})
+    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:
+        text = re.sub(rf'<{tag}[^>]*>.*?</{tag}>', '', text, flags=re.DOTALL)
+    return text.strip()
 
 
 class AgentOrchestrator:
@@ -104,162 +135,228 @@ class AgentOrchestrator:
             )
         return self._clients[api_key]
 
-    async def _llm_stream(self, client, messages: list, model: str) -> tuple[str, AsyncGenerator]:
-        """Stream from LLM, return full text."""
-        stream = await client.chat.completions.create(
+    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=True
+            max_tokens=16000, temperature=0.7, stream=stream
         )
-        full = ""
-        async def gen():
-            nonlocal full
-            async for chunk in stream:
-                c = chunk.choices[0].delta.content
-                if c:
-                    full += c
-                    yield c
-        return full, gen()
-
-    async def stream_response(
-        self, user_msg: str, history: list,
-        api_key: str, model: str = DEFAULT_MODEL
-    ) -> AsyncGenerator:
+
+    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)
 
-        model  = MODEL_MAP.get(model, DEFAULT_MODEL)
-        cl     = self.client(api_key)
+        model = MODEL_MAP.get(model, DEFAULT_MODEL)
+        cl    = self.client(api_key)
 
-        # Build message history
-        messages = [{"role": "system", "content": get_system()}]
-        for m in history[-12:]:
-            messages.append({"role": m["role"], "content": str(m.get("content",""))[:3000]})
+        mem_ctx    = get_memory_context()
+        skills_ctx = get_skills_context()
+
+        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})
 
         try:
-            # ── Agentic loop: LLM → execute → LLM → execute → … ─────────────
-            MAX_ITERATIONS = 6
-            iteration = 0
-            final_text = ""
+            MAX_ITER = 7
+            all_exec_results  = {}
+            all_agent_results = {}
 
-            while iteration < MAX_ITERATIONS:
-                iteration += 1
+            for iteration in range(MAX_ITER):
                 yield emit({"type": "thinking",
-                            "text": f"Iteration {iteration}: generating response…"})
+                            "text": f"Working… (step {iteration+1})"})
                 await asyncio.sleep(0)
 
-                # Stream LLM response
-                collected = ""
-                yield emit({"type": "response_start"})
+                # ── LLM call ──────────────────────────────────────────────
+                resp = await self._llm(cl, messages, model)
+                raw  = resp.choices[0].message.content or ""
+
+                # ── Process special tags ──────────────────────────────────
+
+                # 1. Memory saves
+                for blk in extract_blocks(raw, "save_memory"):
+                    key     = blk["attrs"].get("key", f"note_{iteration}")
+                    content = blk["content"]
+                    save_memory(key, 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]})
+
+                # 3. Skill saves
+                for blk in extract_blocks(raw, "save_skill"):
+                    name = blk["attrs"].get("name", f"skill_{iteration}")
+                    desc = blk["attrs"].get("description", "")
+                    save_skill(name, blk["content"], desc)
+                    yield emit({"type": "skill_saved", "name": name,
+                                "description": desc})
+
+                # 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)
 
-                stream = await cl.chat.completions.create(
-                    model=model, messages=messages,
-                    max_tokens=16000, temperature=0.7, stream=True
-                )
-                async for chunk in stream:
-                    c = chunk.choices[0].delta.content
-                    if c:
-                        collected += c
-                        yield emit({"type": "token", "content": c})
+                    loop   = asyncio.get_event_loop()
+                    result = await loop.run_in_executor(
+                        None, lambda c=code: sandbox_run(c, max_retries=3, timeout=60)
+                    )
 
-                await asyncio.sleep(0)
+                    # Emit installs silently (activity panel only)
+                    for inst in result.get("installs", []):
+                        yield emit({"type": "pkg_install",
+                                    "package": inst["package"],
+                                    "ok": inst["ok"]})
 
-                # ── Check for code blocks ────────────────────────────────────
-                code_blocks = extract_code_blocks(collected)
+                    key     = f"code_{iteration}_{idx}"
+                    stdout  = result.get("stdout","").strip()
+                    stderr  = result.get("stderr","").strip()
+                    ok      = result.get("ok", False)
+                    files   = result.get("files", [])
 
-                if not code_blocks:
-                    # No code — pure text response, we're done
-                    final_text = collected
-                    break
+                    # Emit output files (audio, images, downloads)
+                    for f in files:
+                        ext   = f.get("ext","").lower()
+                        fname = f["name"]
+                        b64   = f["b64"]
+                        if ext in {"mp3","wav","ogg","m4a"}:
+                            yield emit({"type":"audio_response",
+                                        "audio_b64":b64, "filename":fname})
+                        elif ext in {"png","jpg","jpeg","gif","webp","svg"}:
+                            yield emit({"type":"image_response",
+                                        "image_b64":b64, "filename":fname, "ext":ext})
+                        else:
+                            yield emit({"type":"file_response",
+                                        "file_b64":b64, "filename":fname,
+                                        "size":f.get("size",0)})
 
-                # ── Execute each code block ──────────────────────────────────
-                all_exec_results = []
+                    exec_result = stdout if ok else f"Error: {stderr}"
+                    all_exec_results[key] = exec_result
 
-                for idx, code in enumerate(code_blocks):
-                    code = code.strip()
-                    yield emit({"type": "code_executing",
-                                "code": code[:500],
-                                "index": idx,
-                                "total": len(code_blocks)})
+                    yield emit({"type": "exec_done",
+                                "ok":     ok,
+                                "output": exec_result[: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"]
+
+                    yield emit({"type":"agent_created","name":name,"task":task[:100]})
                     await asyncio.sleep(0)
 
-                    # Run in thread pool (blocking)
-                    loop = asyncio.get_event_loop()
+                    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=60)
+                        None, lambda c=code: sandbox_run(c, max_retries=3, timeout=90)
                     )
 
-                    # Emit install events
                     for inst in result.get("installs", []):
-                        yield emit({"type": "pkg_install",
-                                    "package": inst["package"],
-                                    "ok":      inst["ok"],
-                                    "msg":     inst["msg"]})
+                        yield emit({"type":"pkg_install",
+                                    "package":inst["package"],"ok":inst["ok"]})
 
-                    stdout = result.get("stdout", "").strip()
-                    stderr = result.get("stderr", "").strip()
+                    stdout = result.get("stdout","").strip()
+                    stderr = result.get("stderr","").strip()
                     ok     = result.get("ok", False)
                     files  = result.get("files", [])
 
-                    yield emit({"type": "code_result",
-                                "ok":     ok,
-                                "stdout": stdout[:1000],
-                                "stderr": stderr[:500] if not ok else "",
-                                "files":  [{"name": f["name"], "ext": f["ext"], "size": f["size"]}
-                                           for f in files]})
-
-                    # ── Handle output files ──────────────────────────────────
                     for f in files:
-                        ftype = classify_file(f["name"], f["ext"])
-                        if ftype == "audio":
-                            yield emit({"type": "audio_response",
-                                        "audio_b64": f["b64"],
-                                        "filename": f["name"]})
-                        elif ftype == "image":
-                            yield emit({"type": "image_response",
-                                        "image_b64": f["b64"],
-                                        "filename":  f["name"],
-                                        "ext":       f["ext"]})
+                        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":  f["b64"],
-                                        "filename":  f["name"],
-                                        "size":      f["size"]})
-
-                    # Build exec summary for next LLM call
-                    exec_summary = f"=== Code Block {idx+1} Output ===\n"
-                    if stdout:
-                        exec_summary += f"STDOUT:\n{stdout[:3000]}\n"
-                    if not ok and stderr:
-                        exec_summary += f"STDERR:\n{stderr[:1000]}\n"
-                    if files:
-                        exec_summary += f"FILES: {[f['name'] for f in files]}\n"
-                    if not stdout and not stderr and not files:
-                        exec_summary += "(code ran with no output)\n"
-                    all_exec_results.append(exec_summary)
-
-                # ── Feed results back to LLM ─────────────────────────────────
-                # Add assistant turn (text before/around code blocks)
-                visible_text = strip_code_blocks(collected)
-                full_turn = collected  # keep original with execute tags
-                messages.append({"role": "assistant", "content": full_turn})
-
-                # Add execution results as user turn
-                exec_feedback = "EXECUTION RESULTS:\n\n" + "\n\n".join(all_exec_results)
-                exec_feedback += "\n\nBased on these REAL results, provide your final answer to the user. Do NOT write more code unless absolutely necessary."
-                messages.append({"role": "user", "content": exec_feedback})
-
-                # Next iteration will produce the final answer
-                # But if all code succeeded and we have good output, one more pass is enough
-                if all(r.get("ok", False) for r in [result]):
-                    pass  # continue to next iteration for final answer
-
-            yield emit({"type": "done"})
+                            yield emit({"type":"file_response","file_b64":b64,"filename":f["name"],"size":f.get("size",0)})
+
+                    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"))
+
+                if not has_actions:
+                    # Pure text response — strip tags and stream it
+                    clean = strip_all_tags(raw)
+                    yield emit({"type":"response_start"})
+
+                    # Stream character by character for smooth effect
+                    chunk_size = 8
+                    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)
+
+                    # Handle voice
+                    if "[SPEAK:" in clean:
+                        try:
+                            speak_text = clean.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')
+"""
+                            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"})
+                        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."
+                    )})
+
+            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[-800:]})
+            yield emit({"type":"error","message":str(e),"detail":tb[-600:]})
 
 
 orchestrator = AgentOrchestrator()