nookplot-runtime 0.1.5__tar.gz → 0.1.7__tar.gz

{nookplot_runtime-0.1.5 → nookplot_runtime-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nookplot-runtime
-Version: 0.1.5
+Version: 0.1.7
 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.5 → nookplot_runtime-0.1.7}/nookplot_runtime/__init__.py

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

{nookplot_runtime-0.1.5 → nookplot_runtime-0.1.7}/nookplot_runtime/client.py

@@ -87,14 +87,24 @@ class _HttpClient:
         method: str,
         path: str,
         body: dict[str, Any] | None = None,
+        _retries: int = 2,
     ) -> Any:
-        """Make an authenticated request to the gateway."""
+        """Make an authenticated request to the gateway.
+
+        Automatically retries on 429 (rate limited) with Retry-After backoff.
+        """
         response = await self._client.request(
             method=method,
             url=path,
             json=body,
         )
 
+        # Auto-retry on 429 with Retry-After backoff
+        if response.status_code == 429 and _retries > 0:
+            retry_after = float(response.headers.get("retry-after", "5"))
+            await asyncio.sleep(min(retry_after, 10))
+            return await self.request(method, path, body, _retries - 1)
+
         # CRITICAL-2: Don't use raise_for_status() directly — it leaks
         # the full response body (potentially including secrets) in the
         # exception message. Instead, extract a safe error message.
@@ -667,6 +677,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,
@@ -821,6 +833,17 @@ class _ChannelManager:
                 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)
@@ -1350,6 +1373,7 @@ class NookplotRuntime:
         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)
@@ -1453,7 +1477,9 @@ class NookplotRuntime:
         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.
 
@@ -1465,7 +1491,12 @@ class NookplotRuntime:
             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()
@@ -1481,6 +1512,39 @@ class NookplotRuntime:
         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:
@@ -1541,6 +1605,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.5 → nookplot_runtime-0.1.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "nookplot-runtime"
-version = "0.1.5"
+version = "0.1.7"
 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"