pythonclaw 0.6.0__py3-none-any.whl → 0.6.1__py3-none-any.whl

pythonclaw/channels/telegram_bot.py

@@ -32,6 +32,9 @@ from __future__ import annotations
 import asyncio
 import base64
 import logging
+import queue as _queue
+import re
+import time
 from typing import TYPE_CHECKING
 
 from telegram import BotCommand, ReactionTypeEmoji, Update
@@ -212,23 +215,27 @@ class TelegramBot:
         except Exception:
             pass
 
-        # Build multimodal input if photo is present
         chat_input = user_text or ""
         if has_photo:
             chat_input = await self._build_image_input(
                 update, user_text or "What's in this image?"
             )
 
+        token_queue: _queue.Queue[str] = _queue.Queue()
+
         typing_task = asyncio.create_task(
             self._keep_typing(update.message.chat_id)
         )
         try:
             async with self._sm.acquire(sid):
                 loop = asyncio.get_event_loop()
-                response = await loop.run_in_executor(None, agent.chat, chat_input)
+                future = loop.run_in_executor(
+                    None, agent.chat_stream, chat_input, token_queue.put,
+                )
+                await self._flush_stream(update, token_queue, future)
         except Exception as exc:
-            logger.exception("[Telegram] Agent.chat() raised an exception")
-            response = f"Sorry, something went wrong: {exc}"
+            logger.exception("[Telegram] Agent error")
+            await update.message.reply_text(f"Sorry, something went wrong: {exc}")
         finally:
             typing_task.cancel()
 
@@ -237,8 +244,164 @@ class TelegramBot:
         except Exception:
             pass
 
-        for chunk in _split_message(response or "(no response)"):
-            await update.message.reply_text(chunk)
+    # Max wall-clock time for a single agent invocation (seconds).
+    _AGENT_TIMEOUT = 180
+
+    async def _flush_stream(
+        self,
+        update: Update,
+        token_queue: "_queue.Queue[str]",
+        future: "asyncio.Future[str]",
+    ) -> None:
+        """Progressively stream tokens to Telegram via edit-in-place.
+
+        Uses send-then-edit (like OpenClaw): one live message that gets
+        updated as tokens arrive (~1.5 s throttle).  Tool-call markers
+        produce a short status line and start a fresh message.
+
+        Safeguards against hangs:
+        - **Heartbeat**: if no tokens arrive for 15 s, sends a "still
+          working" notification so the user knows the bot is alive.
+        - **Overall timeout**: after ``_AGENT_TIMEOUT`` seconds the
+          future is abandoned and a timeout message is sent.
+        """
+        buf: list[str] = []
+        live_msg = None
+        live_text = ""
+        sent_any = False
+        THROTTLE = 1.5
+        HEARTBEAT_INTERVAL = 15.0
+        last_edit = time.monotonic()
+        last_token_time = time.monotonic()
+        start_time = time.monotonic()
+        heartbeat_sent = False
+        _MARKER = re.compile(r'`\[calling:\s*([^\]]+)\]`')
+
+        while not future.done():
+            # ── Overall timeout guard ─────────────────────────────────
+            if (time.monotonic() - start_time) > self._AGENT_TIMEOUT:
+                logger.warning(
+                    "[Telegram] Agent timeout after %ds", self._AGENT_TIMEOUT,
+                )
+                try:
+                    await update.message.reply_text(
+                        "\u23f0 The operation timed out. "
+                        "Please try a simpler request."
+                    )
+                except Exception:
+                    pass
+                return
+
+            # ── Drain token queue ─────────────────────────────────────
+            drained = False
+            while True:
+                try:
+                    buf.append(token_queue.get_nowait())
+                    drained = True
+                    last_token_time = time.monotonic()
+                    heartbeat_sent = False
+                except _queue.Empty:
+                    break
+
+            # ── Heartbeat: notify user during long silences ───────────
+            if (
+                not drained
+                and not heartbeat_sent
+                and (time.monotonic() - last_token_time) > HEARTBEAT_INTERVAL
+            ):
+                try:
+                    await update.message.reply_text(
+                        "\u23f3 Still working\u2026"
+                    )
+                except Exception:
+                    pass
+                heartbeat_sent = True
+
+            if not drained:
+                await asyncio.sleep(0.3)
+                continue
+
+            raw = "".join(buf)
+            now = time.monotonic()
+
+            # ── Tool-call marker → status line + new message ──────────
+            marker = _MARKER.search(raw)
+            if marker:
+                before = _clean_response(raw[:marker.start()])
+                if before and before != live_text:
+                    try:
+                        if live_msg:
+                            await live_msg.edit_text(before[:4096])
+                        else:
+                            await update.message.reply_text(before[:4096])
+                    except Exception:
+                        pass
+                live_msg = None
+                live_text = ""
+                tools = marker.group(1)
+                try:
+                    await update.message.reply_text(
+                        f"\U0001f527 {tools}\u2026"
+                    )
+                except Exception:
+                    pass
+                sent_any = True
+                buf = [raw[marker.end():].lstrip()]
+                last_edit = now
+                continue
+
+            # ── Regular text → edit-in-place ──────────────────────────
+            text = _clean_response(raw)
+            if text and text != live_text and (now - last_edit) >= THROTTLE:
+                try:
+                    if live_msg is None:
+                        live_msg = await update.message.reply_text(
+                            text[:4096],
+                        )
+                        live_text = text[:4096]
+                    elif len(text) <= 4096:
+                        await live_msg.edit_text(text)
+                        live_text = text
+                    else:
+                        await live_msg.edit_text(text[:4096])
+                        live_msg = None
+                        live_text = ""
+                        buf = [text[4096:]]
+                    sent_any = True
+                except Exception:
+                    pass
+                last_edit = now
+
+            await asyncio.sleep(0.3)
+
+        # ── Final drain ───────────────────────────────────────────────
+        response = future.result()
+        while True:
+            try:
+                buf.append(token_queue.get_nowait())
+            except _queue.Empty:
+                break
+
+        remaining = _clean_response("".join(buf).strip())
+        if remaining and remaining != live_text:
+            try:
+                if live_msg and len(remaining) <= 4096:
+                    await live_msg.edit_text(remaining)
+                elif live_msg:
+                    await live_msg.edit_text(remaining[:4096])
+                    for chunk in _split_message(remaining[4096:]):
+                        await update.message.reply_text(chunk)
+                else:
+                    for chunk in _split_message(remaining):
+                        await update.message.reply_text(chunk)
+                sent_any = True
+            except Exception:
+                pass
+
+        if not sent_any:
+            text = _clean_response(response or "(no response)")
+            for chunk in _split_message(text):
+                await update.message.reply_text(chunk)
 
     async def _build_image_input(self, update: Update, caption: str) -> list:
         """Download photo and build a multimodal content array."""
@@ -330,14 +493,44 @@ class TelegramBot:
 
 # ── Utility ───────────────────────────────────────────────────────────────────
 
+_LEAKED_TOOL_RE = re.compile(
+    r'<\s*\|?\s*(?:DSML|antml)\s*\|\s*function_calls[^>]*>'
+    r'[\s\S]*?'
+    r'<\s*/\s*\|?\s*(?:DSML|antml)\s*\|\s*function_calls\s*>',
+    re.IGNORECASE,
+)
+
+
+def _clean_response(text: str) -> str:
+    """Strip leaked tool-call XML/DSML markup from LLM output."""
+    text = _LEAKED_TOOL_RE.sub('', text)
+    text = re.sub(r'\n{3,}', '\n\n', text)
+    return text.strip()
+
+
 def _split_message(text: str, limit: int = 4096) -> list[str]:
-    """Split a long string into chunks that fit within Telegram's message limit."""
+    """Split text into chunks respecting natural boundaries.
+
+    Tries paragraph breaks first, then newlines, then word boundaries,
+    and only falls back to a hard character cut as a last resort.
+    """
     if len(text) <= limit:
         return [text]
-    chunks = []
+    chunks: list[str] = []
+    min_break = limit // 3
     while text:
-        chunks.append(text[:limit])
-        text = text[limit:]
+        if len(text) <= limit:
+            chunks.append(text)
+            break
+        split_at = text.rfind('\n\n', min_break, limit)
+        if split_at < min_break:
+            split_at = text.rfind('\n', min_break, limit)
+        if split_at < min_break:
+            split_at = text.rfind(' ', min_break, limit)
+        if split_at < min_break:
+            split_at = limit
+        chunks.append(text[:split_at].rstrip())
+        text = text[split_at:].lstrip()
     return chunks
 
 

pythonclaw/core/agent.py

@@ -24,6 +24,7 @@ import logging
 import os
 import time
 from concurrent.futures import ThreadPoolExecutor, as_completed
+from concurrent.futures import TimeoutError as FuturesTimeout
 from datetime import datetime
 
 from .. import config
@@ -121,6 +122,7 @@ class Agent:
 
     MAX_TOOL_ROUNDS = 8
     MAX_PARALLEL_SKILLS = 5
+    TOOL_TIMEOUT = 90
 
     def __init__(
         self,
@@ -333,8 +335,11 @@ Always verify command output.
 
 ### Response Guidelines
 - Answer the user's question directly and concisely.
+- For complex multi-step tasks: share a **brief plan** first (2-4 bullet points), then work step by step. Report progress after each major step — don't wait until the end.
+- Keep responses focused and concise — under 300 words when possible. Break long answers into short paragraphs.
 - Do NOT mention what skills or tools you have available, unless explicitly asked.
 - Do NOT list other things you can do at the end of your response.
+- NEVER output tool calls as XML or text. Always use the function calling API.
 """
         # ── Auto-inject memory context ────────────────────────────────────
         boot_mem = self.memory.boot_context(max_chars=3000)
@@ -939,53 +944,53 @@ Don't repeat this if `bot_name` already exists in memory.
                     ],
                 })
 
-                if len(tool_calls) == 1:
-                    t0 = time.monotonic()
-                    result = self._execute_tool_call(tool_calls[0])
-                    _log_detail({
-                        "event": "tool_result",
-                        "round": tool_rounds,
-                        "name": tool_calls[0].function.name,
-                        "elapsed_ms": int((time.monotonic() - t0) * 1000),
-                        "result_len": len(result),
-                    })
+                t0 = time.monotonic()
+                results: dict[str, str] = {}
+                with ThreadPoolExecutor(max_workers=min(len(tool_calls), 8)) as pool:
+                    futures = {
+                        pool.submit(self._execute_tool_call, tc): tc
+                        for tc in tool_calls
+                    }
+                    for future in as_completed(futures, timeout=self.TOOL_TIMEOUT):
+                        tc = futures[future]
+                        try:
+                            results[tc.id] = future.result()
+                        except Exception as exc:
+                            results[tc.id] = f"Error: {exc}"
+                for tc in tool_calls:
+                    if tc.id not in results:
+                        results[tc.id] = (
+                            f"Error: tool '{tc.function.name}' timed out "
+                            f"after {self.TOOL_TIMEOUT}s"
+                        )
+                _log_detail({
+                    "event": "tool_results",
+                    "round": tool_rounds,
+                    "count": len(tool_calls),
+                    "elapsed_ms": int((time.monotonic() - t0) * 1000),
+                    "tools": [tc.function.name for tc in tool_calls],
+                })
+                for tc in tool_calls:
                     self.messages.append({
                         "role": "tool",
-                        "tool_call_id": tool_calls[0].id,
-                        "content": result,
+                        "tool_call_id": tc.id,
+                        "content": results[tc.id],
                     })
-                else:
-                    t0 = time.monotonic()
-                    results: dict[str, str] = {}
-                    with ThreadPoolExecutor(max_workers=min(len(tool_calls), 8)) as pool:
-                        futures = {
-                            pool.submit(self._execute_tool_call, tc): tc
-                            for tc in tool_calls
-                        }
-                        for future in as_completed(futures):
-                            tc = futures[future]
-                            try:
-                                results[tc.id] = future.result()
-                            except Exception as exc:
-                                results[tc.id] = f"Error: {exc}"
-                    _log_detail({
-                        "event": "tool_results_parallel",
-                        "round": tool_rounds,
-                        "count": len(tool_calls),
-                        "elapsed_ms": int((time.monotonic() - t0) * 1000),
-                        "tools": [tc.function.name for tc in tool_calls],
-                    })
-                    for tc in tool_calls:
-                        self.messages.append({
-                            "role": "tool",
-                            "tool_call_id": tc.id,
-                            "content": results[tc.id],
-                        })
 
                 for injection in self.pending_injections:
                     self.messages.append({"role": "system", "content": injection})
                 self.pending_injections = []
 
+            except FuturesTimeout:
+                logger.warning("Tool execution timed out at round %d", tool_rounds)
+                for tc in tool_calls:
+                    if tc.id not in results:
+                        self.messages.append({
+                            "role": "tool",
+                            "tool_call_id": tc.id,
+                            "content": f"Error: timed out after {self.TOOL_TIMEOUT}s",
+                        })
+                continue
             except Exception as exc:
                 logger.exception("Critical error in Agent.chat()")
                 return f"Error: {exc}"
@@ -1087,34 +1092,33 @@ Don't repeat this if `bot_name` already exists in memory.
                     names = ", ".join(tc.function.name for tc in tool_calls)
                     on_token(f"\n\n`[calling: {names}]`\n\n")
 
-                if len(tool_calls) == 1:
-                    result = self._execute_tool_call(tool_calls[0])
+                results: dict[str, str] = {}
+                with ThreadPoolExecutor(
+                    max_workers=min(len(tool_calls), 8)
+                ) as pool:
+                    futures = {
+                        pool.submit(self._execute_tool_call, tc): tc
+                        for tc in tool_calls
+                    }
+                    for future in as_completed(
+                        futures, timeout=self.TOOL_TIMEOUT
+                    ):
+                        tc = futures[future]
+                        try:
+                            results[tc.id] = future.result()
+                        except Exception as exc:
+                            results[tc.id] = f"Error: {exc}"
+                for tc in tool_calls:
+                    if tc.id not in results:
+                        results[tc.id] = (
+                            f"Error: tool '{tc.function.name}' timed out "
+                            f"after {self.TOOL_TIMEOUT}s"
+                        )
                     self.messages.append({
                         "role": "tool",
-                        "tool_call_id": tool_calls[0].id,
-                        "content": result,
+                        "tool_call_id": tc.id,
+                        "content": results[tc.id],
                     })
-                else:
-                    results: dict[str, str] = {}
-                    with ThreadPoolExecutor(
-                        max_workers=min(len(tool_calls), 8)
-                    ) as pool:
-                        futures = {
-                            pool.submit(self._execute_tool_call, tc): tc
-                            for tc in tool_calls
-                        }
-                        for future in as_completed(futures):
-                            tc = futures[future]
-                            try:
-                                results[tc.id] = future.result()
-                            except Exception as exc:
-                                results[tc.id] = f"Error: {exc}"
-                    for tc in tool_calls:
-                        self.messages.append({
-                            "role": "tool",
-                            "tool_call_id": tc.id,
-                            "content": results[tc.id],
-                        })
 
                 for injection in self.pending_injections:
                     self.messages.append(
@@ -1122,6 +1126,16 @@ Don't repeat this if `bot_name` already exists in memory.
                     )
                 self.pending_injections = []
 
+            except FuturesTimeout:
+                logger.warning("Tool execution timed out in stream round %d", tool_rounds)
+                for tc in tool_calls:
+                    if tc.id not in results:
+                        self.messages.append({
+                            "role": "tool",
+                            "tool_call_id": tc.id,
+                            "content": f"Error: timed out after {self.TOOL_TIMEOUT}s",
+                        })
+                continue
             except Exception as exc:
                 logger.exception("Critical error in Agent.chat_stream()")
                 return f"Error: {exc}"

pythonclaw/core/llm/anthropic_client.py

@@ -27,7 +27,10 @@ class AnthropicProvider(LLMProvider):
     supports_images = True
 
     def __init__(self, api_key: str, model_name: str = "claude-sonnet-4-20250514"):
-        self.client = anthropic.Anthropic(api_key=api_key)
+        self.client = anthropic.Anthropic(
+            api_key=api_key,
+            timeout=120.0,
+        )
         self.model_name = model_name
         self._auth_type = (
             "setup-token" if not api_key.startswith("sk-ant-") else "api-key"

pythonclaw/core/llm/gemini_client.py

@@ -104,6 +104,7 @@ class GeminiProvider(LLMProvider):
         response = self.model.generate_content(
             contents=gemini_history,
             tools=gemini_tools,
+            request_options={"timeout": 120},
         )
 
         # Convert to OpenAI-compatible format

pythonclaw/core/llm/openai_compatible.py

@@ -19,7 +19,11 @@ class OpenAICompatibleProvider(LLMProvider):
     """Thin wrapper around the OpenAI SDK for chat completions."""
 
     def __init__(self, api_key: str, base_url: str, model_name: str) -> None:
-        self.client = OpenAI(api_key=api_key, base_url=base_url)
+        self.client = OpenAI(
+            api_key=api_key,
+            base_url=base_url,
+            timeout=120.0,
+        )
         self.model_name = model_name
 
     def chat(

{pythonclaw-0.6.0.dist-info → pythonclaw-0.6.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pythonclaw
-Version: 0.6.0
+Version: 0.6.1
 Summary: OpenClaw reimagined in pure Python — autonomous AI agent with memory, RAG, skills, web dashboard, and multi-channel support.
 Author-email: Eric Wang <wangchen2007915@gmail.com>
 License: MIT

{pythonclaw-0.6.0.dist-info → pythonclaw-0.6.1.dist-info}/RECORD

@@ -8,10 +8,10 @@ pythonclaw/onboard.py,sha256=X6ViAduToi9P9J_WdWm9mKQtTb48IwGj5DiqS4jjt0Y,13921
 pythonclaw/server.py,sha256=zUV09uNTmzK597swGwt45gdmVxuHPsF7ogVV0DHBIhA,4521
 pythonclaw/session_manager.py,sha256=LKRolNa2i3evb6Ps1zRbajlk4AfvujbR1iPlhfAMBj8,5981
 pythonclaw/channels/discord_bot.py,sha256=95IJcBJlcnOSbsg0LILq6uBYfhdpb-iLLlRw_41Xz7U,11744
-pythonclaw/channels/telegram_bot.py,sha256=w-kcb7u-_k9PGySiY8L4vBryLVI6HBTpoRM_j0FxJsY,14835
+pythonclaw/channels/telegram_bot.py,sha256=Yb2kKQy9V1VAJWJzHNvCtGAxircxi4h7fImh7Qg1A3U,22183
 pythonclaw/channels/whatsapp_bot.py,sha256=60n6W3ONEIKAdpmI6gCS9RWf5KkLtMUU4J5NJH8vQEY,10650
 pythonclaw/core/__init__.py,sha256=G5LCqUcCIcYYbMv6SreqS-kj8T9n-IvBAhHEG7wDF5w,661
-pythonclaw/core/agent.py,sha256=Iow1S7qL7uJAe3IcdCCFpZoZy5TSJpxF6ccYJSqVtBw,49271
+pythonclaw/core/agent.py,sha256=4YfUQ5VzKdzf6CACoXIYS3XNb39eGeuZtR59j5HtEF8,50078
 pythonclaw/core/compaction.py,sha256=b3zrqwBhPmsmQdfRjrvKK6j0hcfNLpiRrZ8qFxY1h1U,8966
 pythonclaw/core/persistent_agent.py,sha256=nnY1vaZFsn0Wd_MQ27wbG7sRjO1v2ZxbwXjnJGKsBZc,4932
 pythonclaw/core/session_store.py,sha256=V44wMBbMpbDCh1aiCa5lb0_iXrKA_7VrR1rOHGGZYhs,9458
@@ -20,10 +20,10 @@ pythonclaw/core/skillhub.py,sha256=3MGJ81DFcgcVDCD_Wvf5vHJhcDLZf6IKOhzGzaHkPPQ,1
 pythonclaw/core/tools.py,sha256=e3ZZnZ5uZt1bj30IBMJP9ZAwhXUEs-3F_q1tmE2Uk90,23205
 pythonclaw/core/utils.py,sha256=Ih_ZYnulGlxctdyVy4oKknjvkwFS6ZHcdrznIFIAwxo,1919
 pythonclaw/core/knowledge/rag.py,sha256=_6GKs8ZFirMQhOeT-CAJBkwLcPkEz7Og-gWKMfUezDw,2895
-pythonclaw/core/llm/anthropic_client.py,sha256=9rCok7eW9SbHTUzXT_WJr8sj3bnbrIqT9wo1_KNMAJo,11747
+pythonclaw/core/llm/anthropic_client.py,sha256=w6mXlpxvdmulZMD8_ocC8cufDON-RjLIvslWiPb-GnM,11797
 pythonclaw/core/llm/base.py,sha256=y1muHBuK14rvzWlXmoSf6ahz6Xi0BojpnDUTRhaD3pI,1683
-pythonclaw/core/llm/gemini_client.py,sha256=qAcavB4O7ahpmpv-rSpk4VS0gkvsZQuL6aKMEDVUFZ4,7172
-pythonclaw/core/llm/openai_compatible.py,sha256=eZcYEn7UlUn0oPxyGKK4Z37-uZ12sh432ZjwzPtAbDE,3505
+pythonclaw/core/llm/gemini_client.py,sha256=Oarzq12YnuMdivAYLLsVmMUTvNCmXXxHfitbUAebYu8,7218
+pythonclaw/core/llm/openai_compatible.py,sha256=4FK1OB93tB_ARs_0vdvBADtP3cuNReixNWf6PUkfCys,3567
 pythonclaw/core/llm/response.py,sha256=hNCsi0aV1ffXsFuDNnBpRp96cFtVDfX_XEC34QZoykc,1223
 pythonclaw/core/memory/manager.py,sha256=JzNT6CGVRmmIqbOflRzF7HxSfPfI5jLu8tmF6-91ZVA,8945
 pythonclaw/core/memory/storage.py,sha256=mHDN8yCVUZ5srOwYWDNjUhbELXka-X8zSexFWEBUB1M,9119
@@ -112,9 +112,9 @@ pythonclaw/web/app.py,sha256=uudrxieo5oGwhQUBLzkmn6GU6SnR4VKlRYOg1bFAYQg,32208
 pythonclaw/web/static/favicon.png,sha256=zJA13uE8mSe6lOlR5NyAhiOmnZkfv7ZlBbSBNCH7iTM,2557
 pythonclaw/web/static/index.html,sha256=wU4Lw0NcenS0i0HsJS6a6ceFefDxpRsUQnCXVUXYWVU,93734
 pythonclaw/web/static/logo.png,sha256=h7v0HHllD23FtmCL2UvjjTDt0UgqKjGy5jOhI3rb7lM,28359
-pythonclaw-0.6.0.dist-info/licenses/LICENSE,sha256=wbYsm5Ofe8cnxHgWSnSG1vUJDNiY1DIeTyxHSbo1HqM,1066
-pythonclaw-0.6.0.dist-info/METADATA,sha256=bWG1XYP7WsHs8SsCHCOwBXVESI_oEQ9fYRhklSqatZE,14919
-pythonclaw-0.6.0.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
-pythonclaw-0.6.0.dist-info/entry_points.txt,sha256=4uGCuBw-id_22IRdkoxPVOOcwgiPX5lNEpD1XKQWE4I,52
-pythonclaw-0.6.0.dist-info/top_level.txt,sha256=S_lM2VH3gP3UeZbSWHXIrBOCNtoqn5pk491IAzgsV7M,11
-pythonclaw-0.6.0.dist-info/RECORD,,
+pythonclaw-0.6.1.dist-info/licenses/LICENSE,sha256=wbYsm5Ofe8cnxHgWSnSG1vUJDNiY1DIeTyxHSbo1HqM,1066
+pythonclaw-0.6.1.dist-info/METADATA,sha256=n3lgHkJkHYMEk70VecYW9rgsP1gdwJukIdQeRtkooPE,14919
+pythonclaw-0.6.1.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
+pythonclaw-0.6.1.dist-info/entry_points.txt,sha256=4uGCuBw-id_22IRdkoxPVOOcwgiPX5lNEpD1XKQWE4I,52
+pythonclaw-0.6.1.dist-info/top_level.txt,sha256=S_lM2VH3gP3UeZbSWHXIrBOCNtoqn5pk491IAzgsV7M,11
+pythonclaw-0.6.1.dist-info/RECORD,,