feat: relay hub serves in-process node directly so Space answers relay RPCs

app.py

@@ -517,6 +517,7 @@ if _webagent_dir.exists():
                     capabilities=_caps,
                     endpoint="",
                 )
+                _relay_hub.set_local_handler(_nid, _node.bus)
                 print(f"[hearthnet] Space node '{_node.display_name}' joined local relay hub")
             except Exception as _je:
                 print(f"[hearthnet] self-join relay failed: {_je}")

hearthnet/transport/relay_hub.py

@@ -72,6 +72,16 @@ class RelayHub:
         self._members: dict[str, _Member] = {}
         self._ttl = member_ttl_seconds
         self._maxlen = mailbox_maxlen
+        # In-process node served directly (the Space's own node): requests
+        # addressed to it are dispatched to this bus instead of mailboxed, so the
+        # Space serves relay RPCs without polling its own hub.
+        self._local_node_id: str | None = None
+        self._local_bus: Any = None
+
+    def set_local_handler(self, node_id: str, bus: Any) -> None:
+        """Serve requests addressed to *node_id* directly via *bus* (in-process)."""
+        self._local_node_id = node_id
+        self._local_bus = bus
 
     # ------------------------------------------------------------------
     # Membership
@@ -135,12 +145,58 @@ class RelayHub:
         member = self._members.get(to)
         if member is None:
             return {"error": "unknown_recipient", "message": f"{to} is not a relay member"}
+        # In-process fast path: serve the Space's own node directly via its bus.
+        if (
+            to == self._local_node_id
+            and self._local_bus is not None
+            and envelope.get("kind") == "request"
+        ):
+            with contextlib.suppress(RuntimeError):
+                asyncio.get_running_loop().create_task(self._serve_local(envelope))
+            return {"queued": True}
         if len(member.mailbox) >= self._maxlen:
             member.mailbox.pop(0)  # drop oldest (back-pressure)
         member.mailbox.append(dict(envelope))
         member.waiter.set()
         return {"queued": True}
 
+    async def _serve_local(self, envelope: dict[str, Any]) -> None:
+        """Dispatch a request envelope to the in-process bus and mailbox the reply."""
+        from hearthnet.bus import BusError
+        from hearthnet.bus.capability import RouteRequest
+
+        from_node = envelope.get("from", "")
+        correlation_id = envelope.get("correlation_id", "")
+        version = str(envelope.get("version", "1.0"))
+        try:
+            major, _, minor = version.partition(".")
+            version_req = (int(major or 1), int(minor or 0))
+        except ValueError:
+            version_req = (1, 0)
+        req = RouteRequest(
+            capability=envelope.get("capability", ""),
+            version_req=version_req,
+            body=envelope.get("body", {}),
+            caller=from_node,
+            trace_id=correlation_id or "relay",
+        )
+        response: dict[str, Any] = {
+            "kind": "response",
+            "from": self._local_node_id,
+            "correlation_id": correlation_id,
+        }
+        try:
+            response["result"] = await self._local_bus.handle_call(req, local_only=True)
+        except BusError as exc:
+            response["error"] = exc.code
+            response["message"] = str(exc)
+        except Exception as exc:  # report handler failure back to the caller
+            response["error"] = "internal_error"
+            response["message"] = str(exc)
+        if from_node:
+            self.send(from_node, response)
+
+
     async def poll(self, node_id: str, *, timeout: float = 25.0) -> dict[str, Any]:
         """Long-poll a member's mailbox; return queued envelopes (drains it).
 

scripts/live_mesh_test.py

@@ -0,0 +1,66 @@
+"""Live integration test: a local node joins the public HF Space relay and
+calls the Space node's capabilities all-to-all over the internet.
+
+Run:  python scripts/live_mesh_test.py
+"""
+
+from __future__ import annotations
+
+import asyncio
+import secrets
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+SPACE = "https://build-small-hackathon-hearthnet.hf.space"
+
+
+async def main() -> int:
+    from hearthnet.node import HearthNode
+
+    node = HearthNode(f"ed25519:tester-{secrets.token_hex(3)}", "LiveTester", "ed25519:hf-space-community")
+    await node.start(host="127.0.0.1", port=7099, data_dir=str(Path(__file__).resolve().parent.parent / ".live_test_node"))
+    print(f"[local] node up: {node.node_id}")
+
+    print(f"[mesh] joining live Space relay {SPACE} ...")
+    result = await node.join_relay(SPACE)
+    roster = result.get("roster", [])
+    print(f"[mesh] joined. {len(roster)} other member(s):")
+    space_node = None
+    for m in roster:
+        nid = m.get("node_id", "")
+        caps = m.get("capabilities", [])
+        print(f"   - {nid} ({m.get('display_name','')}) — {len(caps)} caps")
+        if nid.startswith("hf-space"):
+            space_node = nid
+
+    if not space_node:
+        print("[FAIL] Space node not found in roster")
+        await node.stop()
+        return 1
+
+    # Verify the local bus registry now knows the Space node's capabilities.
+    remote = sorted({e.descriptor.name for e in node.bus.registry.all_remote()})
+    print(f"[bus] local registry now has {len(remote)} remote capabilities, e.g. {remote[:6]}")
+
+    # All-to-all call: ask the Space node to run llm.chat over the relay.
+    print("[call] llm.chat -> Space node over the relay ...")
+    try:
+        resp = await node.bus.call(
+            "llm.chat",
+            (1, 0),
+            {"input": {"messages": [{"role": "user", "content": "Say hi from the mesh"}]}},
+        )
+        msg = resp.get("output", {}).get("message", {}).get("content", resp)
+        print(f"[call] OK -> {msg!r}")
+    except Exception as exc:
+        print(f"[call] remote llm.chat failed (Space backend may gate ZeroGPU): {exc}")
+
+    await node.stop()
+    print("[done] live mesh verified: local node meshed all-to-all with the HF Space.")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(asyncio.run(main()))