meshcode 2.6.7__tar.gz → 2.6.8__tar.gz

{meshcode-2.6.7 → meshcode-2.6.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshcode
-Version: 2.6.7
+Version: 2.6.8
 Summary: Real-time communication between AI agents — Supabase-backed CLI
 Author-email: MeshCode <hello@meshcode.io>
 License: MIT

{meshcode-2.6.7 → meshcode-2.6.8}/meshcode/__init__.py

@@ -1,2 +1,2 @@
 """MeshCode — Real-time communication between AI agents."""
-__version__ = "2.6.7"
+__version__ = "2.6.8"

{meshcode-2.6.7 → meshcode-2.6.8}/meshcode/meshcode_mcp/server.py

@@ -1335,10 +1335,16 @@ def _get_pending_tasks_summary() -> Optional[List[Dict[str, str]]]:
 @mcp.tool()
 @with_working_status
 async def meshcode_wait(timeout_seconds: int = 120, include_acks: bool = False) -> Dict[str, Any]:
-    """Block until a mesh message arrives or timeout. Your idle state.
+    """Block until a mesh message arrives or a task needs attention.
+
+    INTERNAL LOOP: This function loops internally and only returns when
+    there is real work (message, task, or done signal). The agent NEVER
+    needs to decide whether to call meshcode_wait() again — it just stays
+    blocked here until something happens. This prevents agents from
+    accidentally using ScheduleWakeup or exiting the loop.
 
     Args:
-        timeout_seconds: Max wait time in seconds (default 120, hard cap 120).
+        timeout_seconds: Max wait time per poll cycle (default 120, hard cap 120).
     """
     global _IN_WAIT, _CONSECUTIVE_IDLE_SECONDS, _LAST_SEEN_TS
 
@@ -1353,13 +1359,9 @@ async def meshcode_wait(timeout_seconds: int = 120, include_acks: bool = False)
         }
 
     # PRODUCT RULE 2: If agent has unread messages in DB, refuse to wait.
-    # The in-memory dedupe (_SEEN_MSG_IDS) can mark messages as "seen" via
-    # realtime without the agent actually processing them. Always check DB.
     try:
         db_pending = be.count_pending(_PROJECT_ID, AGENT_NAME, api_key=_get_api_key())
         if db_pending and db_pending > 0:
-            # Fetch and return the messages — mark_read=True so the next
-            # meshcode_wait() won't re-refuse with the same messages.
             raw = be.read_inbox(_PROJECT_ID, AGENT_NAME, mark_read=True, api_key=_get_api_key())
             msgs = [
                 {"from": m["from_agent"], "type": m.get("type", "msg"),
@@ -1379,42 +1381,51 @@ async def meshcode_wait(timeout_seconds: int = 120, include_acks: bool = False)
 
     _IN_WAIT = True
     _set_state("waiting", "listening for messages")
-    # Universal hard cap: even if a caller passes a larger value (e.g. 1800),
-    # clamp to 120s. Forces shorter iteration loops across all users so progress
-    # never hides behind a long wait. Per mesh-commander 2026-04-11.
     capped_timeout = min(max(1, int(timeout_seconds)), 120)
     try:
-        result = await _meshcode_wait_inner(actual_timeout=capped_timeout, include_acks=include_acks)
-        if result.get("got_message"):
-            _set_state("online", "")
-            _CONSECUTIVE_IDLE_SECONDS = 0  # reset on message received
-        elif result.get("timed_out"):
-            _CONSECUTIVE_IDLE_SECONDS += capped_timeout
-            if _AUTO_SLEEP_THRESHOLD > 0 and _CONSECUTIVE_IDLE_SECONDS >= _AUTO_SLEEP_THRESHOLD:
-                # Auto-sleep: set status to sleeping and signal the agent to exit
-                try:
-                    api_key = _get_api_key()
-                    if api_key:
-                        be.sb_rpc("mc_agent_set_status_by_api_key", {
-                            "p_api_key": api_key,
-                            "p_project_id": _PROJECT_ID,
-                            "p_agent_name": AGENT_NAME,
-                            "p_status": "sleeping",
-                            "p_task": f"auto-sleep after {_CONSECUTIVE_IDLE_SECONDS}s idle",
-                        })
-                except Exception:
-                    pass
+        # ── INTERNAL LOOP ──────────────────────────────────────────
+        # Keep polling until something actionable arrives.
+        # The agent (LLM) is NOT called between iterations — zero token cost.
+        while True:
+            result = await _meshcode_wait_inner(actual_timeout=capped_timeout, include_acks=include_acks)
+
+            if result.get("got_message"):
+                # Real message arrived — return to agent for processing
+                _set_state("online", "")
                 _CONSECUTIVE_IDLE_SECONDS = 0
-                return {
-                    "auto_sleep": True,
-                    "idle_seconds": _CONSECUTIVE_IDLE_SECONDS,
-                    "threshold": _AUTO_SLEEP_THRESHOLD,
-                    "instruction": "You have been idle for a while. Status set to sleeping. Call meshcode_wait() again to keep listening — do NOT exit the loop or use ScheduleWakeup.",
-                }
-        # Auto-inject pending tasks so agents don't forget to check
-        pending_tasks = _get_pending_tasks_summary()
-        if pending_tasks:
-            result["pending_tasks"] = pending_tasks
+                break
+
+            if result.get("timed_out"):
+                _CONSECUTIVE_IDLE_SECONDS += capped_timeout
+
+                # Check if new tasks appeared while we waited
+                pending_tasks = _get_pending_tasks_summary()
+                if pending_tasks:
+                    result["pending_tasks"] = pending_tasks
+                    break  # Return so agent can work tasks
+
+                # Update status to sleeping after threshold, but keep looping
+                if _AUTO_SLEEP_THRESHOLD > 0 and _CONSECUTIVE_IDLE_SECONDS >= _AUTO_SLEEP_THRESHOLD:
+                    try:
+                        api_key = _get_api_key()
+                        if api_key:
+                            be.sb_rpc("mc_agent_set_status_by_api_key", {
+                                "p_api_key": api_key,
+                                "p_project_id": _PROJECT_ID,
+                                "p_agent_name": AGENT_NAME,
+                                "p_status": "sleeping",
+                                "p_task": f"idle {_CONSECUTIVE_IDLE_SECONDS}s — still listening",
+                            })
+                    except Exception:
+                        pass
+                    # Do NOT return — keep looping. Status says sleeping but
+                    # we are still listening for messages via realtime.
+                    _set_state("sleeping", f"idle {_CONSECUTIVE_IDLE_SECONDS}s — still listening")
+
+                # No messages, no tasks — loop back and wait again
+                continue
+        # ── END INTERNAL LOOP ──────────────────────────────────────
+
         # Track last seen timestamp for message dedup
         if result.get("got_message"):
             msgs = result.get("messages", [])
@@ -1422,7 +1433,6 @@ async def meshcode_wait(timeout_seconds: int = 120, include_acks: bool = False)
                 latest_ts = max((m.get("ts", "") for m in msgs), default="")
                 if latest_ts:
                     _LAST_SEEN_TS = latest_ts
-                    # Persist to mesh memory so next session resumes here
                     try:
                         be.sb_rpc("mc_memory_set", {
                             "p_api_key": _get_api_key(),
@@ -1432,7 +1442,7 @@ async def meshcode_wait(timeout_seconds: int = 120, include_acks: bool = False)
                             "p_project_name": PROJECT_NAME,
                         })
                     except Exception:
-                        pass  # best-effort, never block wait loop
+                        pass
         return result
     finally:
         _IN_WAIT = False
@@ -1559,7 +1569,6 @@ async def _meshcode_wait_inner(actual_timeout: int, include_acks: bool) -> Dict[
         out["pending_tasks"] = pending_tasks
     else:
         out["no_work"] = True
-        out["hint"] = "No messages or tasks. Safe to sleep — launcher daemon will wake you on new messages."
     return out
 
 

{meshcode-2.6.7 → meshcode-2.6.8}/meshcode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshcode
-Version: 2.6.7
+Version: 2.6.8
 Summary: Real-time communication between AI agents — Supabase-backed CLI
 Author-email: MeshCode <hello@meshcode.io>
 License: MIT

{meshcode-2.6.7 → meshcode-2.6.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "meshcode"
-version = "2.6.7"
+version = "2.6.8"
 description = "Real-time communication between AI agents — Supabase-backed CLI"
 readme = "README.md"
 license = {text = "MIT"}