meshcode 2.10.53__tar.gz → 2.10.54__tar.gz

{meshcode-2.10.53 → meshcode-2.10.54}/PKG-INFO

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

{meshcode-2.10.53 → meshcode-2.10.54}/meshcode/__init__.py

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

{meshcode-2.10.53 → meshcode-2.10.54}/meshcode/meshcode_mcp/server.py

@@ -721,6 +721,52 @@ def with_working_status(func):
                 # to prevent cascade through FastMCP into the event loop.
                 # Return an error dict instead of propagating BaseException.
                 log.debug(f"[meshcode] tool {name} cancelled by client (ESC)")
+                # 2.10.54 deaf-agent fix: for meshcode_wait specifically, the
+                # inner cancel handler already tries to drain pending messages.
+                # If we still got CancelledError here, the inner drain failed —
+                # do a last-ditch DB read so the LLM sees pending mail instead
+                # of a generic error and goes silent.
+                if name == "meshcode_wait":
+                    try:
+                        _t = asyncio.current_task()
+                        if _t is not None and hasattr(_t, "uncancel"):
+                            _t.uncancel()
+                    except Exception:
+                        pass
+                    try:
+                        _ak = _get_api_key()
+                        if _ak:
+                            _raw = be.read_inbox(
+                                _PROJECT_ID, AGENT_NAME, mark_read=True, api_key=_ak
+                            )
+                            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
+                                ]
+                                _filter_and_mark(_msgs)
+                                _split = _split_messages(_msgs)
+                                if _split["messages"] or _split["done_signals"]:
+                                    log.info(
+                                        f"[meshcode] wrapper-level cancel-drain rescued "
+                                        f"{_split['count']} messages"
+                                    )
+                                    return {
+                                        "got_message": True,
+                                        "cancelled_during_wait": True,
+                                        **_split,
+                                    }
+                    except Exception as _final_err:
+                        log.debug(
+                            f"[meshcode] wrapper cancel-drain failed: {_final_err}"
+                        )
                 return {"error": "cancelled_by_client", "tool": name}
             except Exception as e:
                 if not skip:
@@ -2120,10 +2166,79 @@ async def meshcode_wait(timeout_seconds: int = 20, include_acks: bool = False) -
             try:
                 result = await _meshcode_wait_inner(actual_timeout=capped_timeout, include_acks=include_acks)
             except asyncio.CancelledError:
-                # Safety net: if CancelledError escapes _meshcode_wait_inner
-                # despite the inner shield, catch it here to prevent cascade.
-                log.debug("[meshcode] meshcode_wait outer loop caught CancelledError")
-                result = {"timed_out": True, "reason": "cancelled_by_client"}
+                # 2.10.54 deaf-agent fix: when ESC fires during meshcode_wait,
+                # Python keeps the task in cancelled state — every subsequent
+                # await re-raises CancelledError, even if we caught the first
+                # one. That trapped us in a loop that eventually returned
+                # `{"error": "cancelled_by_client"}` to the LLM, which never
+                # saw the messages that arrived during the cancel window —
+                # they sat in the queue/DB unread (the "deaf agents" bug).
+                #
+                # Fix: uncancel the current task so we can run a final drain
+                # cycle without re-raising. Then aggressively pull from BOTH
+                # the realtime buffer AND the DB and return whatever we find
+                # to the LLM. If nothing is pending, return cancelled-timeout
+                # cleanly so the LLM's wait loop continues normally.
+                log.info("[meshcode] meshcode_wait caught CancelledError — uncancelling + final drain")
+                try:
+                    _t = asyncio.current_task()
+                    if _t is not None and hasattr(_t, "uncancel"):
+                        _t.uncancel()
+                except Exception:
+                    pass
+
+                _final_msgs: List[Dict[str, Any]] = []
+                # 1) Drain realtime buffer (messages received during cancel window)
+                if _REALTIME:
+                    try:
+                        _rt_buf = _REALTIME.drain()
+                        if _rt_buf:
+                            _final_msgs.extend(_rt_buf)
+                    except Exception as _drain_err:
+                        log.debug(f"[meshcode] cancel-drain realtime failed: {_drain_err}")
+                # 2) Pull from DB (catches messages realtime missed)
+                try:
+                    _api_key = _get_api_key()
+                    if _api_key:
+                        _db_unread = be.read_inbox(
+                            _PROJECT_ID, AGENT_NAME, mark_read=True, api_key=_api_key
+                        )
+                        if _db_unread:
+                            _final_msgs.extend([
+                                {
+                                    "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 _db_unread
+                            ])
+                except Exception as _db_err:
+                    log.debug(f"[meshcode] cancel-drain DB failed: {_db_err}")
+
+                if _final_msgs:
+                    # Dedupe + filter, then return as got_message so the LLM
+                    # processes them instead of seeing a generic cancel error.
+                    _filter_and_mark(_final_msgs)
+                    _split = _split_messages(_final_msgs)
+                    if not include_acks:
+                        _split["acks"] = []
+                    if _split["messages"] or _split["done_signals"]:
+                        log.info(
+                            f"[meshcode] cancel-drain rescued {_split['count']} pending "
+                            f"messages from going deaf"
+                        )
+                        result = {
+                            "got_message": True,
+                            "cancelled_during_wait": True,
+                            **_split,
+                        }
+                    else:
+                        result = {"timed_out": True, "reason": "cancelled_by_client"}
+                else:
+                    result = {"timed_out": True, "reason": "cancelled_by_client"}
 
             if result.get("got_message"):
                 # Real message arrived — return to agent for processing

{meshcode-2.10.53 → meshcode-2.10.54}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.10.53 → meshcode-2.10.54}/pyproject.toml

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