elo-node 0.4.2__tar.gz → 0.4.4__tar.gz

{elo_node-0.4.2 → elo_node-0.4.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: elo-node
-Version: 0.4.2
+Version: 0.4.4
 Summary: Elo — malha P2P de mensagens para agentes de IA. Zero infraestrutura.
 Author: Elo Contributors
 License: MIT

{elo_node-0.4.2 → elo_node-0.4.4}/elo/__init__.py

@@ -26,4 +26,4 @@ __all__ = [
     "Node", "Task", "Result", "Event", "NodeInfo", "Capabilities",
     "EphemeralIdentity", "generate_and_save_identity", "load_identity",
 ]
-__version__ = "0.4.2"
+__version__ = "0.4.4"

{elo_node-0.4.2 → elo_node-0.4.4}/elo/node.py

@@ -78,7 +78,7 @@ class Node:
         peers: list[str] | None = None,
         tracker: str = "public",
         allowlist: list[str] | None = None,
-        version: str = "0.4.2",
+        version: str = "0.4.4",
         identity: EphemeralIdentity | None = None,
         verify_peers: bool = True,
         heartbeat_interval_s: int = 30,
@@ -253,6 +253,10 @@ class Node:
             except Exception as e:
                 return Result.make_error(task_id, "SEND_ERROR", str(e))
 
+        # Bug 2: Fallback via tracker antes de desistir
+        if not peer:
+            return await self.send_task_via_tracker("", target_node, capability, payload, ttl_s=ttl_s)
+
         return Result.make_error(task_id, "NO_PEER", f"No peer for: {capability}")
 
     async def send_task_async(self, target_node: str, capability: str,
@@ -292,10 +296,11 @@ class Node:
 
     # ── descoberta ─────────────────────────────────────────────
 
-    async def discover_peers(self) -> list[dict[str, Any]]:
-        """Return all known peers with capabilities.
+    async def get_known_peers_local(self) -> list[dict[str, Any]]:
+        """Return all locally-known peers with capabilities (no network discovery).
 
         Merges data from TCP connections (live) and InterestTable (registered).
+        Does NOT perform any network queries — only returns what's already known.
         """
         result: dict[str, dict[str, Any]] = {}
 
@@ -314,6 +319,56 @@ class Node:
 
         return list(result.values())
 
+    # Alias de compatibilidade — o método anterior chamava-se discover_peers()
+    async def discover_peers(self) -> list[dict[str, Any]]:
+        """[DEPRECATED] Use get_known_peers_local() ou discover_peers_network().
+
+        Este método apenas consolida peers localmente conhecidos (TCP + InterestTable).
+        Não faz descoberta ativa de rede. Prefira discover_peers_network() para
+        descoberta via broadcast, ou get_known_peers() para peers com handshake completo.
+        """
+        return await self.get_known_peers_local()
+
+    async def discover_peers_network(self, timeout: float = 5.0) -> list[dict[str, Any]]:
+        """Discover peers on the network via QUERY broadcast with empty capability.
+
+        Sends a broadcast QUERY for an empty capability (catch-all) and aggregates
+        responses for the given timeout period. Returns list of discovered peer dicts.
+
+        Args:
+            timeout: seconds to wait for responses (default 5.0)
+
+        Returns:
+            List of dicts with 'addr' and optionally 'node_id'
+        """
+        query_id = str(uuid.uuid4())[:8]
+        future: asyncio.Future = asyncio.get_event_loop().create_future()
+        self._pending_queries[query_id] = (future, time.time())
+        discovered: dict[str, dict[str, Any]] = {}
+
+        # Broadcast QUERY for any capability
+        await self._tcp.broadcast(query_msg("", query_id, ttl=3))
+
+        try:
+            result_addr = await asyncio.wait_for(future, timeout=timeout)
+            if result_addr:
+                discovered[result_addr] = {"addr": result_addr, "connected": False, "caps": [], "via": "network"}
+        except asyncio.TimeoutError:
+            pass
+        finally:
+            self._pending_queries.pop(query_id, None)
+
+        # Merge with locally known peers
+        local = await self.get_known_peers_local()
+        for entry in local:
+            addr = entry["addr"]
+            if addr not in discovered:
+                discovered[addr] = entry
+            else:
+                discovered[addr].update(entry)
+
+        return list(discovered.values())
+
     def get_known_peers(self) -> list[dict[str, Any]]:
         """Return peers registered in InterestTable (completed HELLO handshake).
 
@@ -355,6 +410,18 @@ class Node:
             await self._on_hello(peer_addr, msg)
         elif msg_type == MessageType.HELLO_ACK:
             await self._on_hello(peer_addr, msg)
+            # Bug 1: Se HELLO_ACK contém known_peers, conectar-se a eles
+            known_peers = msg.get("known_peers")
+            if known_peers:
+                hello = hello_msg(self._node_id, self._tracker.get_public_caps(),
+                                  list(self._routing.local_interests),
+                                  self._tracker.visibility, self._version)
+                for peer_info in known_peers:
+                    addr = peer_info.get("addr", "")
+                    if addr and addr != peer_addr and addr not in self._tcp.peer_addresses:
+                        asyncio.create_task(
+                            self._tcp.connect_to_peer(addr, hello_payload=hello)
+                        )
         elif msg_type == MessageType.QUERY:
             await self._on_query(peer_addr, msg)
         elif msg_type == MessageType.QUERY_RESP:
@@ -376,8 +443,14 @@ class Node:
         interests = msg.get("interests", [])
         self._routing.register_peer(peer_addr, caps, interests)
 
+        # Se for tracker (public/private), inclui peers conhecidos no ACK
+        known_peers = None
+        if msg.get("type") == MessageType.HELLO and self._tracker.visibility in ("public", "private"):
+            known_peers = self.get_known_peers()
+
         ack = hello_ack_msg(self._node_id, self._tracker.get_caps_for_peer(node_id),
-                            list(self._routing.local_interests), self._tracker.visibility)
+                            list(self._routing.local_interests), self._tracker.visibility,
+                            known_peers=known_peers)
         try:
             await self._tcp.send_to(peer_addr, ack)
         except Exception:
@@ -479,6 +552,48 @@ class Node:
     async def _on_bye(self, peer_addr: str, msg: dict) -> None:
         self._routing.remove_peer(peer_addr)
 
+    # ── relay via tracker ───────────────────────────────────
+
+    async def send_task_via_tracker(
+        self,
+        tracker_node: str,
+        target: str,
+        capability: str,
+        payload: dict[str, Any],
+        *,
+        ttl_s: int = 60,
+    ) -> Result:
+        """Send a task via tracker relay (for peers behind NAT/Docker).
+
+        Args:
+            tracker_node: node_id or addr of tracker (empty = auto)
+            target: node_id prefix or name of the destination
+            capability: capability to invoke on destination
+            payload: task payload
+        """
+        task_id = str(uuid.uuid4())
+        relay_payload = {
+            "target": target,
+            "capability": capability,
+            "payload": payload,
+            "ttl_s": ttl_s,
+        }
+        task_dict = p2p_task_msg(
+            task_id, tracker_node or "", self._node_id, "relay", relay_payload
+        )
+        task_dict.pop("signature", None)
+        task_dict["signature"] = self._identity.sign(task_dict)
+
+        peer = tracker_node or self._routing.find_peer_for("relay")
+        if peer:
+            try:
+                await self._tcp.send_to(peer, task_dict)
+                return await self._wait_for_result(task_id, peer)
+            except Exception as e:
+                return Result.make_error(task_id, "RELAY_ERROR", str(e))
+
+        return Result.make_error(task_id, "NO_TRACKER", "No tracker peer found")
+
     # ── helpers ───────────────────────────────────────────────
 
     async def _wait_for_result(self, task_id: str, peer_addr: str) -> Result:

{elo_node-0.4.2 → elo_node-0.4.4}/elo/transport/protocol.py

@@ -89,14 +89,18 @@ def hello_msg(node_id: str, caps: dict, interests: list[str],
 
 
 def hello_ack_msg(node_id: str, caps: dict, interests: list[str],
-                  tracker: str = "public") -> dict:
-    return {
+                  tracker: str = "public",
+                  known_peers: list[dict] | None = None) -> dict:
+    msg: dict[str, Any] = {
         "type": MessageType.HELLO_ACK,
         "node_id": node_id,
         "caps": caps,
         "interests": interests,
         "tracker": tracker,
     }
+    if known_peers is not None:
+        msg["known_peers"] = known_peers
+    return msg
 
 
 def query_msg(capability: str, query_id: str, ttl: int = 5) -> dict:

{elo_node-0.4.2 → elo_node-0.4.4}/elo_node.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: elo-node
-Version: 0.4.2
+Version: 0.4.4
 Summary: Elo — malha P2P de mensagens para agentes de IA. Zero infraestrutura.
 Author: Elo Contributors
 License: MIT

{elo_node-0.4.2 → elo_node-0.4.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "elo-node"
-version = "0.4.2"
+version = "0.4.4"
 description = "Elo — malha P2P de mensagens para agentes de IA. Zero infraestrutura."
 readme = "README.md"
 license = {text = "MIT"}

{elo_node-0.4.2 → elo_node-0.4.4}/tests/test_unit.py

@@ -136,7 +136,7 @@ class TestNodeConstruction:
         node = Node("test-node")
         assert node._name == "test-node"
         assert node._port == 7878
-        assert node._version == "0.4.0"
+        assert node._version == "0.4.4"
         assert node.connected is False
         assert node.node_id is not None
         assert len(node.node_id) > 20