meshcode 2.6.7__tar.gz → 2.6.9__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshcode
-Version: 2.6.7
+Version: 2.6.9
 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.9}/meshcode/__init__.py

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

{meshcode-2.6.7 → meshcode-2.6.9}/meshcode/meshcode_mcp/realtime.py

@@ -148,6 +148,25 @@ class RealtimeListener:
             }
             await ws.send(json.dumps(join_msg))
 
+            # Wait for phx_reply to confirm subscription was accepted.
+            self._subscription_ok = False
+            try:
+                reply_raw = await asyncio.wait_for(ws.recv(), timeout=10.0)
+                reply = json.loads(reply_raw)
+                reply_status = (reply.get("payload") or {}).get("status")
+                if reply_status == "ok":
+                    self._subscription_ok = True
+                    log.info(f"Realtime subscription OK for {self.agent_name} on {topic}")
+                else:
+                    log.error(
+                        f"Realtime subscription FAILED for {self.agent_name}: "
+                        f"status={reply_status} payload={reply.get('payload')}"
+                    )
+            except asyncio.TimeoutError:
+                log.error(f"Realtime subscription TIMEOUT — no phx_reply in 10s for {self.agent_name}")
+            except Exception as e:
+                log.error(f"Realtime subscription error reading phx_reply: {e}")
+
             # Heartbeat task to keep the connection alive
             heartbeat_task = asyncio.create_task(self._heartbeat(ws))
             try:
@@ -247,3 +266,7 @@ class RealtimeListener:
     @property
     def is_connected(self) -> bool:
         return self._connected
+
+    @property
+    def is_subscribed(self) -> bool:
+        return self._connected and getattr(self, "_subscription_ok", False)

{meshcode-2.6.7 → meshcode-2.6.9}/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
@@ -1515,7 +1525,11 @@ async def _meshcode_wait_inner(actual_timeout: int, include_acks: bool) -> Dict[
             if shaped:
                 return shaped
 
-        # 2) Real async wait — zero CPU, zero Supabase calls.
+    # Determine if realtime is actually delivering events.
+    _rt_live = _REALTIME and _REALTIME.is_subscribed
+
+    if _rt_live:
+        # 2a) Real async wait — zero CPU, zero Supabase calls.
         woke = await _REALTIME.wait_for_message(timeout=float(actual_timeout))
         if woke:
             buffered = _REALTIME.drain()
@@ -1524,11 +1538,37 @@ async def _meshcode_wait_inner(actual_timeout: int, include_acks: bool) -> Dict[
                 if shaped:
                     return shaped
     else:
-        # Realtime unavailable — plain sleep fallback so we still honor timeout.
-        await asyncio.sleep(actual_timeout)
+        # 2b) Realtime NOT subscribed — aggressive DB polling every 5s
+        # so messages arrive within seconds, not after 120s timeout.
+        _poll_interval = 5
+        _elapsed = 0
+        while _elapsed < actual_timeout:
+            await asyncio.sleep(min(_poll_interval, actual_timeout - _elapsed))
+            _elapsed += _poll_interval
+            try:
+                api_key = _get_api_key()
+                if api_key:
+                    db_pending = be.count_pending(_PROJECT_ID, AGENT_NAME, api_key=api_key)
+                    if db_pending and db_pending > 0:
+                        raw = be.read_inbox(_PROJECT_ID, AGENT_NAME, mark_read=True, api_key=api_key)
+                        if raw:
+                            msgs = [
+                                {"from": m["from_agent"], "type": m.get("type", "msg"),
+                                 "ts": m.get("created_at"), "payload": m.get("payload", {}),
+                                 "id": m.get("id"), "parent_id": m.get("parent_msg_id")}
+                                for m in raw
+                            ]
+                            deduped = _filter_and_mark(msgs)
+                            if deduped:
+                                split = _split_messages(deduped)
+                                if not include_acks:
+                                    split["acks"] = []
+                                if split["messages"] or split["done_signals"]:
+                                    return {"got_message": True, "source": "db_poll_fallback", **split}
+            except Exception:
+                pass
 
-    # Fallback: poll DB for messages that realtime may have missed
-    # (connection drop, startup race, etc.)
+    # Final fallback: one last DB check (covers realtime path missing msgs)
     try:
         api_key = _get_api_key()
         if api_key:
@@ -1559,7 +1599,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
 
 
@@ -1638,6 +1677,7 @@ def meshcode_check(include_acks: bool = False, since: Optional[str] = None) -> D
         "agent": AGENT_NAME,
         "project": PROJECT_NAME,
         "realtime_connected": _REALTIME.is_connected if _REALTIME else False,
+        "realtime_subscribed": _REALTIME.is_subscribed if _REALTIME else False,
         **split,
     }
     # Auto-inject pending tasks

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshcode
-Version: 2.6.7
+Version: 2.6.9
 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.9}/pyproject.toml

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