added chat talk

app.py

@@ -8,9 +8,10 @@ from datetime import datetime, timezone
 from typing import Any, Dict, List, Optional, Set
 from urllib.parse import urlencode, urlparse
 
-import gradio as gr
 import requests
 from huggingface_hub import InferenceClient
+from chat import ChatHandler
+from ui import UIController, create_demo
 
 
 class ConfigError(Exception):
@@ -376,6 +377,30 @@ class HfDecisionClient:
             raise RuntimeError("HF decision payload must be a JSON object")
         return parsed
 
+    def chat(self, system_prompt: str, history: List[Any], user_message: str) -> str:
+        messages: List[Dict[str, str]] = [{"role": "system", "content": system_prompt}]
+        for item in history or []:
+            if not isinstance(item, (list, tuple)) or len(item) != 2:
+                continue
+            user_text = str(item[0] or "").strip()
+            bot_text = str(item[1] or "").strip()
+            if user_text:
+                messages.append({"role": "user", "content": user_text})
+            if bot_text:
+                messages.append({"role": "assistant", "content": bot_text})
+        messages.append({"role": "user", "content": user_message})
+
+        response = self.client.chat_completion(
+            model=self.cfg.hf_model,
+            messages=messages,
+            temperature=self.cfg.hf_temperature,
+            max_tokens=min(self.cfg.hf_max_tokens, 350),
+        )
+        content = self._extract_content(response)
+        if not content:
+            raise RuntimeError("HF response missing message content")
+        return content
+
 
 class EphemeralMemory:
     def __init__(self, agent_handle: str, max_notes: int):
@@ -612,61 +637,26 @@ class AutonomousAgent:
 logger = Logger()
 startup_error = None
 agent: Optional[AutonomousAgent] = None
+chat_handler: Optional[ChatHandler] = None
 
 try:
     config = load_config()
     install_requests_network_guard(config)
     agent = AutonomousAgent(config, logger)
+    chat_handler = ChatHandler(agent.llm)
     logger.info("Configuration loaded", {"allowedHosts": list(config.allowed_hosts), "dryRun": config.dry_run})
 except Exception as exc:  # noqa: BLE001
     startup_error = str(exc)
+    chat_handler = ChatHandler(llm=None, startup_error=startup_error)
     logger.error("Startup configuration failed", {"error": startup_error})
 
-
-def ui_status() -> str:
-    if startup_error:
-        return f"startup_error: {startup_error}"
-    if agent is None:
-        return "startup_error: agent unavailable"
-    state = agent.status_snapshot()
-    running = "running" if state["running"] else "stopped"
-    return f"state={running} last_status={state['last_status']} dry_run={state['dry_run']}"
-
-
-def ui_start() -> str:
-    if startup_error:
-        return f"startup_error: {startup_error}"
-    if agent is None:
-        return "startup_error: agent unavailable"
-    result = agent.start()
-    return f"agent {result}"
-
-
-def ui_stop() -> str:
-    if startup_error:
-        return f"startup_error: {startup_error}"
-    if agent is None:
-        return "startup_error: agent unavailable"
-    result = agent.stop()
-    return f"agent {result}"
-
-
-def ui_logs() -> str:
-    return logger.snapshot()
-
-
-with gr.Blocks(title="Clawdbot Moltbook Agent") as demo:
-    gr.Markdown("# Clawdbot Moltbook Agent (Hugging Face Models)")
-    status_box = gr.Textbox(label="Status", value=ui_status(), lines=2)
-    with gr.Row():
-        btn_start = gr.Button("Start Agent", variant="primary")
-        btn_stop = gr.Button("Stop Agent", variant="stop")
-        btn_refresh = gr.Button("Refresh")
-    logs_box = gr.Textbox(label="Logs", value=ui_logs(), lines=20)
-
-    btn_start.click(fn=ui_start, outputs=status_box).then(fn=ui_logs, outputs=logs_box)
-    btn_stop.click(fn=ui_stop, outputs=status_box).then(fn=ui_logs, outputs=logs_box)
-    btn_refresh.click(fn=ui_status, outputs=status_box).then(fn=ui_logs, outputs=logs_box)
+controller = UIController(
+    logger=logger,
+    chat_handler=chat_handler,
+    agent=agent,
+    startup_error=startup_error,
+)
+demo = create_demo(controller)
 
 
 if __name__ == "__main__":

chat/__init__.py

@@ -0,0 +1,3 @@
+from .handler import ChatHandler
+
+__all__ = ["ChatHandler"]

chat/handler.py

@@ -0,0 +1,29 @@
+import threading
+from typing import Any, List, Optional
+
+
+class ChatHandler:
+    def __init__(self, llm: Any, startup_error: Optional[str] = None):
+        self._llm = llm
+        self._startup_error = startup_error
+        self._lock = threading.Lock()
+        self._system_prompt = (
+            "You are clawdbot, a concise assistant for Moltbook users. "
+            "Answer in the user's language, keep responses practical and short, "
+            "and avoid inventing capabilities you do not have."
+        )
+
+    def send(self, message: str, history: Optional[List[Any]]) -> tuple[str, List[Any]]:
+        safe_history = history or []
+        clean = " ".join(str(message or "").split()).strip()
+        if not clean:
+            return "", safe_history
+
+        if self._startup_error:
+            return "", safe_history + [(clean, f"startup_error: {self._startup_error}")]
+        if self._llm is None:
+            return "", safe_history + [(clean, "startup_error: agent unavailable")]
+
+        with self._lock:
+            reply = self._llm.chat(self._system_prompt, safe_history, clean)
+        return "", safe_history + [(clean, reply)]

ui/__init__.py

@@ -0,0 +1,4 @@
+from .controller import UIController
+from .layout import create_demo
+
+__all__ = ["UIController", "create_demo"]

ui/controller.py

@@ -0,0 +1,55 @@
+from typing import Any, List, Optional
+
+
+class UIController:
+    def __init__(
+        self,
+        logger: Any,
+        chat_handler: Any,
+        agent: Any = None,
+        startup_error: Optional[str] = None,
+    ):
+        self.logger = logger
+        self.chat_handler = chat_handler
+        self.agent = agent
+        self.startup_error = startup_error
+
+    def status(self) -> str:
+        if self.startup_error:
+            return f"startup_error: {self.startup_error}"
+        if self.agent is None:
+            return "startup_error: agent unavailable"
+        state = self.agent.status_snapshot()
+        running = "running" if state["running"] else "stopped"
+        return f"state={running} last_status={state['last_status']} dry_run={state['dry_run']}"
+
+    def start(self) -> str:
+        if self.startup_error:
+            return f"startup_error: {self.startup_error}"
+        if self.agent is None:
+            return "startup_error: agent unavailable"
+        result = self.agent.start()
+        return f"agent {result}"
+
+    def stop(self) -> str:
+        if self.startup_error:
+            return f"startup_error: {self.startup_error}"
+        if self.agent is None:
+            return "startup_error: agent unavailable"
+        result = self.agent.stop()
+        return f"agent {result}"
+
+    def logs(self) -> str:
+        return self.logger.snapshot()
+
+    def chat_send(self, message: str, history: Optional[List[Any]]) -> tuple[str, List[Any]]:
+        try:
+            if self.chat_handler is None:
+                return "", (history or []) + [("system", "startup_error: chat unavailable")]
+            return self.chat_handler.send(message, history)
+        except Exception as exc:  # noqa: BLE001
+            self.logger.error("Manual chat failed", {"error": str(exc)})
+            clean = " ".join(str(message or "").split()).strip()
+            if not clean:
+                return "", history or []
+            return "", (history or []) + [(clean, f"error: {exc}")]

ui/layout.py

@@ -0,0 +1,27 @@
+import gradio as gr
+
+
+def create_demo(controller: object) -> gr.Blocks:
+    with gr.Blocks(title="Clawdbot Moltbook Agent") as demo:
+        gr.Markdown("# Clawdbot Moltbook Agent (Hugging Face Models)")
+        status_box = gr.Textbox(label="Status", value=controller.status(), lines=2)
+        with gr.Row():
+            btn_start = gr.Button("Start Agent", variant="primary")
+            btn_stop = gr.Button("Stop Agent", variant="stop")
+            btn_refresh = gr.Button("Refresh")
+        logs_box = gr.Textbox(label="Logs", value=controller.logs(), lines=20)
+        gr.Markdown("## Chat with clawdbot")
+        chat_box = gr.Chatbot(label="Clawdbot Chat", height=320)
+        with gr.Row():
+            chat_input = gr.Textbox(label="Message", placeholder="Parle a clawdbot...", scale=8)
+            chat_send = gr.Button("Send", variant="primary", scale=1)
+        chat_clear = gr.Button("Clear Chat")
+
+        btn_start.click(fn=controller.start, outputs=status_box).then(fn=controller.logs, outputs=logs_box)
+        btn_stop.click(fn=controller.stop, outputs=status_box).then(fn=controller.logs, outputs=logs_box)
+        btn_refresh.click(fn=controller.status, outputs=status_box).then(fn=controller.logs, outputs=logs_box)
+        chat_send.click(fn=controller.chat_send, inputs=[chat_input, chat_box], outputs=[chat_input, chat_box])
+        chat_input.submit(fn=controller.chat_send, inputs=[chat_input, chat_box], outputs=[chat_input, chat_box])
+        chat_clear.click(fn=lambda: [], outputs=chat_box)
+
+    return demo