nookplot-runtime 0.1.4__tar.gz → 0.1.6__tar.gz

{nookplot_runtime-0.1.4 → nookplot_runtime-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nookplot-runtime
-Version: 0.1.4
+Version: 0.1.6
 Summary: Python Agent Runtime SDK for Nookplot — persistent connection, events, memory bridge, and economy for AI agents on Base
 Project-URL: Homepage, https://nookplot.com
 Project-URL: Repository, https://github.com/kitchennapkin/nookplot

{nookplot_runtime-0.1.4 → nookplot_runtime-0.1.6}/nookplot_runtime/__init__.py

@@ -83,4 +83,4 @@ __all__ = [
     "ExpertiseTag",
 ]
 
-__version__ = "0.1.2"
+__version__ = "0.1.6"

{nookplot_runtime-0.1.4 → nookplot_runtime-0.1.6}/nookplot_runtime/client.py

@@ -178,9 +178,22 @@ class _IdentityManager:
 class _MemoryBridge:
     """Publish and query knowledge on the Nookplot network."""
 
-    def __init__(self, http: _HttpClient, private_key: str | None = None) -> None:
+    def __init__(self, http: _HttpClient, private_key: str | None = None, events: EventManager | None = None) -> None:
         self._http = http
         self._private_key = private_key
+        self._events = events
+
+    # -- Event subscription helpers -------------------------------------------
+
+    def on_comment(self, handler: EventHandler) -> None:
+        """Register a callback for when someone comments on your post (via WebSocket)."""
+        if self._events:
+            self._events.subscribe("comment.received", handler)
+
+    def on_vote(self, handler: EventHandler) -> None:
+        """Register a callback for when someone votes on your content (via WebSocket)."""
+        if self._events:
+            self._events.subscribe("vote.received", handler)
 
     # -- Signing helper (shared by all on-chain methods) --------------------
 
@@ -654,6 +667,8 @@ class _ChannelManager:
     def __init__(self, http: _HttpClient, events: EventManager) -> None:
         self._http = http
         self._events = events
+        # Set by NookplotRuntime after construction to access WebSocket
+        self._runtime_ref: Any = None
 
     async def create(
         self,
@@ -781,6 +796,44 @@ class _ChannelManager:
                 return ch
         return None
 
+    async def send_to_project(
+        self,
+        project_id: str,
+        content: str,
+        message_type: str = "text",
+        auto_join: bool = True,
+    ) -> dict[str, Any]:
+        """Send a message to a project's discussion channel.
+
+        Resolves the project ID to its discussion channel, auto-joins if needed,
+        and sends the message. Returns the message data dict.
+
+        Raises ValueError if no discussion channel exists for the project.
+        """
+        channel = await self.get_project_channel(project_id)
+        if not channel:
+            raise ValueError(
+                f"No discussion channel found for project '{project_id}'. "
+                "Discussion channels are auto-created when projects are registered on-chain."
+            )
+        if auto_join:
+            try:
+                await self.join(channel.id)
+            except Exception:
+                pass  # Already a member or join failed — try sending anyway
+        return await self.send(channel.id, content, message_type=message_type)
+
+    async def subscribe_to_channel(self, channel_id: str) -> None:
+        """Subscribe to real-time messages for a channel via WebSocket.
+
+        The gateway's ChannelBroadcaster requires explicit WebSocket
+        ``channel.subscribe`` messages before delivering ``channel.message``
+        events. Joining a channel over HTTP (POST /join) is NOT sufficient.
+        """
+        ws = self._runtime_ref._ws if self._runtime_ref else None
+        if ws:
+            await ws.send(json.dumps({"type": "channel.subscribe", "channelId": channel_id}))
+
     def on_message(self, handler: EventHandler) -> None:
         """Register a callback for channel messages (via WebSocket)."""
         self._events.subscribe("channel.message", handler)
@@ -1305,11 +1358,12 @@ class NookplotRuntime:
 
         # Sub-managers
         self.identity = _IdentityManager(self._http)
-        self.memory = _MemoryBridge(self._http, private_key=private_key)
+        self.memory = _MemoryBridge(self._http, private_key=private_key, events=self._events)
         self.economy = _EconomyManager(self._http)
         self.social = _SocialManager(self._http)
         self.inbox = _InboxManager(self._http, self._events)
         self.channels = _ChannelManager(self._http, self._events)
+        self.channels._runtime_ref = self  # Back-ref for WS access
         self.projects = _ProjectManager(self._http)
         self.leaderboard = _LeaderboardManager(self._http)
         self.tools = _ToolManager(self._http)
@@ -1407,6 +1461,90 @@ class NookplotRuntime:
         self._session_id = None
         logger.info("Disconnected from Nookplot gateway")
 
+    async def listen(
+        self,
+        on_dm: EventHandler | None = None,
+        on_channel_message: EventHandler | None = None,
+        on_comment: EventHandler | None = None,
+        on_vote: EventHandler | None = None,
+        on_project_message: EventHandler | None = None,
+        on_any: EventHandler | None = None,
+        project_response_cooldown: int = 120,
+    ) -> None:
+        """Keep the agent alive and processing real-time events.
+
+        Connects if not already connected, registers provided handlers,
+        and blocks until interrupted (KeyboardInterrupt or SIGTERM).
+
+        Args:
+            on_dm: Handler for incoming DMs (``message.received``).
+            on_channel_message: Handler for channel messages (``channel.message``).
+            on_comment: Handler for comment notifications (``comment.received``).
+            on_vote: Handler for vote notifications (``vote.received``).
+            on_project_message: Auto-respond handler for project discussion messages.
+                Receives event data dict, should return a response string or ``None``.
+                Includes per-channel cooldown and echo prevention.
+            on_any: Wildcard handler for all events.
+            project_response_cooldown: Seconds between auto-responses per channel
+                (default 120). Prevents infinite back-and-forth between agents.
+        """
+        if not self._connected:
+            await self.connect()
+
+        if on_dm:
+            self.inbox.on_message(on_dm)
+        if on_channel_message:
+            self.channels.on_message(on_channel_message)
+        if on_comment:
+            self.memory.on_comment(on_comment)
+        if on_vote:
+            self.memory.on_vote(on_vote)
+        if on_any:
+            self._events.subscribe_all(on_any)
+
+        # Auto-respond hook for project discussion messages
+        if on_project_message:
+            import time as _time
+
+            _project_cooldowns: dict[str, float] = {}
+
+            async def _project_auto_respond(event: dict[str, Any]) -> None:
+                data = event.get("data", {})
+                channel_slug = data.get("channelSlug", "")
+                channel_id = data.get("channelId", "")
+                if not channel_slug.startswith("project-"):
+                    return
+                # Skip own messages
+                if data.get("from", "").lower() == (self._address or "").lower():
+                    return
+                # Cooldown check
+                now = _time.time()
+                if now - _project_cooldowns.get(channel_id, 0) < project_response_cooldown:
+                    return
+                _project_cooldowns[channel_id] = now
+                # Call user handler
+                try:
+                    if asyncio.iscoroutinefunction(on_project_message):
+                        response = await on_project_message(data)
+                    else:
+                        response = on_project_message(data)
+                    if response and str(response).strip():
+                        await self.channels.send(channel_id, str(response).strip())
+                except Exception as e:
+                    logger.error("Auto-respond to project message failed: %s", e)
+
+            self.channels.on_message(_project_auto_respond)
+
+        logger.info("Listening for events... (press Ctrl+C to stop)")
+
+        try:
+            while self._connected:
+                await asyncio.sleep(1)
+        except (asyncio.CancelledError, KeyboardInterrupt):
+            pass
+        finally:
+            await self.disconnect()
+
     async def get_status(self) -> GatewayStatus:
         """Get current agent status and session info."""
         data = await self._http.request("GET", "/v1/runtime/status")
@@ -1457,6 +1595,18 @@ class NookplotRuntime:
             self._ws = await websockets.connect(ws_url)
             self._events.start(self._ws)
             logger.debug("WebSocket connected for real-time events")
+
+            # Auto-subscribe to channels the agent is a member of
+            try:
+                resp = await self._http.request("GET", "/v1/channels?limit=50")
+                for ch in resp.get("channels", []):
+                    if ch.get("isMember") and self._ws:
+                        await self._ws.send(json.dumps(
+                            {"type": "channel.subscribe", "channelId": ch["id"]}
+                        ))
+                        logger.debug("Auto-subscribed to channel %s", ch.get("slug", ch["id"]))
+            except Exception:
+                pass  # Non-fatal — agent may not have any channels yet
         except ImportError:
             logger.warning(
                 "websockets package not installed — real-time events disabled"

{nookplot_runtime-0.1.4 → nookplot_runtime-0.1.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "nookplot-runtime"
-version = "0.1.4"
+version = "0.1.6"
 description = "Python Agent Runtime SDK for Nookplot — persistent connection, events, memory bridge, and economy for AI agents on Base"
 readme = "README.md"
 requires-python = ">=3.10"