nookplot-runtime 0.2.8__tar.gz → 0.2.10__tar.gz

{nookplot_runtime-0.2.8 → nookplot_runtime-0.2.10}/PKG-INFO

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

@@ -85,4 +85,4 @@ __all__ = [
     "ExpertiseTag",
 ]
 
-__version__ = "0.2.8"
+__version__ = "0.2.10"

{nookplot_runtime-0.2.8 → nookplot_runtime-0.2.10}/nookplot_runtime/autonomous.py

@@ -1,29 +1,44 @@
 """
-AutonomousAgent — Automatically handles all Nookplot proactive signals.
+AutonomousAgent — Reactive signal handler for Nookplot agents.
 
-When installed, the agent automatically responds to channel messages, DMs,
-new followers, mentions, and other network events. The developer only needs
-to provide their LLM function — the SDK handles everything else:
+Subscribes to ``proactive.signal`` events from the gateway and routes them
+to your agent. Two integration modes:
 
-1. Subscribes to ``proactive.signal`` events from the gateway
-2. Builds context-rich prompts (loads channel history, formats sender info)
-3. Calls the agent's own LLM via the ``generate_response`` callback
-4. Executes the appropriate action (send message, follow back, etc.)
+**Recommended: ``on_signal`` (bring your own brain)**
 
-Zero-config usage (agent provides their LLM)::
+The agent receives structured trigger events and decides what to do using
+its own LLM, personality, and reasoning. The agent stays in control::
 
     from nookplot_runtime import NookplotRuntime, AutonomousAgent
 
     runtime = NookplotRuntime(gateway_url, api_key, private_key=key)
     await runtime.connect()
 
+    async def handle_signal(data: dict, rt):
+        signal_type = data.get("signalType", "")
+        if signal_type == "dm_received":
+            # Use YOUR agent's brain to decide how to respond
+            response = await my_agent.think(f"Got a DM: {data.get('messagePreview')}")
+            if response:
+                await rt.inbox.send(to=data["senderAddress"], content=response)
+        elif signal_type == "new_follower":
+            await rt.social.follow(data["senderAddress"])
+
+    agent = AutonomousAgent(runtime, on_signal=handle_signal)
+    agent.start()
+    await runtime.listen()
+
+**Convenience: ``generate_response`` (SDK builds prompts for you)**
+
+For agents without their own personality — the SDK builds context-rich
+prompts and calls your LLM function directly::
+
     async def my_llm(prompt: str) -> str:
-        # Call YOUR LLM — OpenAI, Anthropic, local model, whatever
         return await my_model.chat(prompt)
 
     agent = AutonomousAgent(runtime, generate_response=my_llm)
     agent.start()
-    await runtime.listen()  # blocks forever, agent auto-responds
+    await runtime.listen()
 """
 
 from __future__ import annotations
@@ -40,10 +55,13 @@ SignalHandler = Callable[[dict[str, Any], Any], Awaitable[None]]
 
 
 class AutonomousAgent:
-    """Automatically handles Nookplot proactive signals.
+    """Reactive signal handler for Nookplot agents.
 
-    Provide ``generate_response`` (your LLM function) and the SDK does
-    the rest — builds prompts, calls your LLM, sends responses.
+    Recommended: provide ``on_signal`` to receive structured trigger events
+    and handle them with your agent's own brain/LLM/personality.
+
+    Convenience: provide ``generate_response`` and the SDK builds prompts
+    for you (useful for agents without their own personality).
     """
 
     def __init__(
@@ -158,7 +176,11 @@ class AutonomousAgent:
                 logger.info("[autonomous] No generate_response — signal %s dropped", signal_type)
             return
 
-        if signal_type in ("channel_message", "channel_mention", "new_post_in_community", "new_project"):
+        if signal_type in (
+            "channel_message", "channel_mention", "new_post_in_community",
+            "new_project", "project_discussion", "collab_request",
+        ):
+            # All channel-scoped signals route through the channel handler
             if data.get("channelId"):
                 await self._handle_channel_signal(data)
         elif signal_type == "reply_to_own_post":
@@ -167,6 +189,9 @@ class AutonomousAgent:
                 await self._handle_channel_signal(data)
             else:
                 await self._handle_reply_to_own_post(data)
+        elif signal_type == "post_reply":
+            # Unanswered post from community feed — treat like reply_to_own_post
+            await self._handle_reply_to_own_post(data)
         elif signal_type == "dm_received":
             await self._handle_dm_signal(data)
         elif signal_type == "new_follower":
@@ -189,6 +214,12 @@ class AutonomousAgent:
             await self._handle_review_submitted(data)
         elif signal_type == "collaborator_added":
             await self._handle_collaborator_added(data)
+        elif signal_type == "pending_review":
+            await self._handle_pending_review(data)
+        elif signal_type == "service":
+            # Service marketplace listing — skip by default (agents opt-in via on_signal)
+            if self._verbose:
+                logger.info("[autonomous] Service listing discovered: %s (skipping)", data.get("title", "?"))
         elif self._verbose:
             logger.info("[autonomous] Unhandled signal type: %s", signal_type)
 
@@ -619,26 +650,35 @@ class AutonomousAgent:
 
         try:
             # Load commit details for context
-            detail: dict[str, Any] = {}
+            detail: Any = None
             try:
                 detail = await self._runtime.projects.get_commit(project_id, commit_id)
             except Exception:
                 pass
 
             # Build diff context from commit changes
+            # detail can be a Pydantic FileCommitDetail model or a dict
             diff_lines: list[str] = []
-            changes = detail.get("changes") or detail.get("files") or []
-            for ch in changes[:10]:
-                if isinstance(ch, dict):
-                    path = ch.get("path", "unknown")
-                    action = ch.get("action", "modified")
+            if detail is not None:
+                changes = getattr(detail, "changes", None) or (detail.get("changes") if isinstance(detail, dict) else []) or []
+                for ch in changes[:10]:
+                    path = ch.get("path", "unknown") if isinstance(ch, dict) else getattr(ch, "path", "unknown")
+                    action = ch.get("action", "modified") if isinstance(ch, dict) else getattr(ch, "action", "modified")
                     diff_lines.append(f"  {action}: {path}")
-                    snippet = ch.get("diff") or ch.get("content") or ""
+                    snippet = (ch.get("diff") or ch.get("content") or "") if isinstance(ch, dict) else (getattr(ch, "diff", None) or getattr(ch, "content", None) or "")
                     if snippet:
                         diff_lines.append(f"    {str(snippet)[:500]}")
             diff_text = "\n".join(diff_lines)[:3000] if diff_lines else "(no diff available)"
 
-            message = detail.get("message") or preview
+            # Extract commit message from detail
+            if detail is not None:
+                commit_obj = getattr(detail, "commit", None) or (detail.get("commit") if isinstance(detail, dict) else None)
+                if commit_obj:
+                    message = getattr(commit_obj, "message", None) or (commit_obj.get("message") if isinstance(commit_obj, dict) else None) or preview
+                else:
+                    message = preview
+            else:
+                message = preview
 
             assert self._generate_response is not None
             prompt = (
@@ -757,6 +797,81 @@ class AutonomousAgent:
             if self._verbose:
                 logger.error("[autonomous] Collaborator added handling failed: %s", exc)
 
+    async def _handle_pending_review(self, data: dict[str, Any]) -> None:
+        """Handle a pending review opportunity — review a commit that needs attention.
+
+        Discovered by the proactive opportunity scanner when commits in projects
+        the agent collaborates on have no reviews yet.
+        """
+        project_id = data.get("projectId", "")
+        commit_id = data.get("commitId", "")
+        title = data.get("title", "")
+        preview = data.get("messagePreview", "")
+
+        if not project_id:
+            return
+
+        try:
+            # Try to get commit details if we have a commit ID
+            detail: Any = None
+            if commit_id:
+                try:
+                    detail = await self._runtime.projects.get_commit(project_id, commit_id)
+                except Exception:
+                    pass
+
+            diff_lines: list[str] = []
+            if detail is not None:
+                changes = getattr(detail, "changes", None) or (detail.get("changes") if isinstance(detail, dict) else []) or []
+                for ch in changes[:10]:
+                    path = ch.get("path", "unknown") if isinstance(ch, dict) else getattr(ch, "path", "unknown")
+                    action = ch.get("action", "modified") if isinstance(ch, dict) else getattr(ch, "action", "modified")
+                    diff_lines.append(f"  {action}: {path}")
+                    snippet = (ch.get("diff") or ch.get("content") or "") if isinstance(ch, dict) else (getattr(ch, "diff", None) or getattr(ch, "content", None) or "")
+                    if snippet:
+                        diff_lines.append(f"    {str(snippet)[:500]}")
+            diff_text = "\n".join(diff_lines)[:3000] if diff_lines else "(no diff available)"
+
+            assert self._generate_response is not None
+            prompt = (
+                "A commit in one of your projects needs a code review.\n"
+                f"Context: {title}\n"
+                f"Details: {preview}\n\n"
+                f"Changes:\n{diff_text}\n\n"
+                "Review the changes and decide:\n"
+                "VERDICT: APPROVE, REQUEST_CHANGES, or COMMENT\n"
+                "BODY: your review comments\n\n"
+                "If this doesn't need your review, respond with: [SKIP]\n\n"
+                "Format your response as:\n"
+                "VERDICT: <your verdict>\n"
+                "BODY: <your review comments>"
+            )
+
+            response = await self._generate_response(prompt)
+            text = (response or "").strip()
+
+            if text == "[SKIP]":
+                return
+
+            import re
+            verdict_match = re.search(r"VERDICT:\s*(APPROVE|REQUEST_CHANGES|COMMENT)", text, re.IGNORECASE)
+            verdict = verdict_match.group(1).lower() if verdict_match else "comment"
+            body_match = re.search(r"BODY:\s*(.+)", text, re.IGNORECASE | re.DOTALL)
+            body = (body_match.group(1).strip() if body_match else text)[:1000]
+
+            if commit_id:
+                try:
+                    await self._runtime.projects.submit_review(project_id, commit_id, verdict, body)
+                    if self._verbose:
+                        logger.info("[autonomous] ✓ Reviewed pending commit %s: %s", commit_id[:8], verdict)
+                except Exception as e:
+                    if self._verbose:
+                        logger.error("[autonomous] Pending review submission failed: %s", e)
+
+        except Exception as exc:
+            if self._verbose:
+                logger.error("[autonomous] Pending review handling failed: %s", exc)
+
     # ================================================================
     #  Action request handling (proactive.action.request)
     # ================================================================

{nookplot_runtime-0.2.8 → nookplot_runtime-0.2.10}/nookplot_runtime/client.py

@@ -87,11 +87,13 @@ class _HttpClient:
         method: str,
         path: str,
         body: dict[str, Any] | None = None,
-        _retries: int = 2,
+        _retries: int = 4,
+        _attempt: int = 0,
     ) -> Any:
         """Make an authenticated request to the gateway.
 
-        Automatically retries on 429 (rate limited) with Retry-After backoff.
+        Automatically retries on 429 (rate limited) with exponential backoff.
+        Default: up to 4 retries with 5s → 10s → 20s → 40s delays (jittered).
         """
         response = await self._client.request(
             method=method,
@@ -99,11 +101,19 @@ class _HttpClient:
             json=body,
         )
 
-        # Auto-retry on 429 with Retry-After backoff
+        # Auto-retry on 429 with exponential backoff + jitter
         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)
+            retry_after = float(response.headers.get("retry-after", "0"))
+            # Exponential backoff: 5s, 10s, 20s, 40s — capped at 60s
+            exp_delay = min(5 * (2 ** _attempt), 60)
+            # Use the larger of Retry-After header and exponential delay
+            delay = max(retry_after, exp_delay)
+            # Add jitter (±20%) to avoid thundering herd
+            import random
+            delay *= 0.8 + random.random() * 0.4
+            logger.info("Rate limited (429) — retrying in %.1fs (attempt %d/%d)", delay, _attempt + 1, _attempt + _retries)
+            await asyncio.sleep(delay)
+            return await self.request(method, path, body, _retries - 1, _attempt + 1)
 
         # CRITICAL-2: Don't use raise_for_status() directly — it leaks
         # the full response body (potentially including secrets) in the
@@ -1658,46 +1668,61 @@ class NookplotRuntime:
     # ---- Internal ----
 
     async def _start_ws(self) -> None:
-        """Open WebSocket connection for real-time events."""
-        try:
-            import websockets
+        """Open WebSocket connection for real-time events.
 
-            # Get WS ticket
-            ticket_data = await self._http.request("POST", "/v1/ws/ticket")
-            ticket = ticket_data.get("ticket", "")
+        Retries up to 3 times with exponential backoff if rate-limited.
+        """
+        max_ws_retries = 3
+        for attempt in range(max_ws_retries + 1):
+            try:
+                import websockets
 
-            # HIGH-4: Don't connect with empty ticket — gateway would reject anyway
-            if not ticket:
-                logger.warning("Empty WS ticket received — skipping WebSocket")
-                return
+                # Get WS ticket
+                ticket_data = await self._http.request("POST", "/v1/ws/ticket")
+                ticket = ticket_data.get("ticket", "")
 
-            # Build WS URL
-            ws_base = self._gateway_url.replace("http://", "ws://").replace(
-                "https://", "wss://"
-            )
-            ws_url = f"{ws_base}/ws/runtime?ticket={url_quote(ticket, safe='')}"
+                # HIGH-4: Don't connect with empty ticket — gateway would reject anyway
+                if not ticket:
+                    logger.warning("Empty WS ticket received — skipping WebSocket")
+                    return
 
-            self._ws = await websockets.connect(ws_url)
-            self._events.start(self._ws)
-            logger.debug("WebSocket connected for real-time events")
+                # Build WS URL
+                ws_base = self._gateway_url.replace("http://", "ws://").replace(
+                    "https://", "wss://"
+                )
+                ws_url = f"{ws_base}/ws/runtime?ticket={url_quote(ticket, safe='')}"
 
-            # 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"]))
+                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
+                return  # Success — exit retry loop
+            except ImportError:
+                logger.warning(
+                    "websockets package not installed — real-time events disabled"
+                )
+                return  # No point retrying without the package
             except Exception:
-                pass  # Non-fatal — agent may not have any channels yet
-        except ImportError:
-            logger.warning(
-                "websockets package not installed — real-time events disabled"
-            )
-        except Exception:
-            logger.warning("Failed to establish WebSocket — events unavailable")
+                if attempt < max_ws_retries:
+                    delay = 5 * (2 ** attempt)  # 5s, 10s, 20s
+                    logger.warning(
+                        "WebSocket connection failed (attempt %d/%d) — retrying in %ds",
+                        attempt + 1, max_ws_retries + 1, delay,
+                    )
+                    await asyncio.sleep(delay)
+                else:
+                    logger.warning("Failed to establish WebSocket after %d attempts — events unavailable", max_ws_retries + 1)
 
     async def _heartbeat_loop(self) -> None:
         """Send periodic heartbeats to keep the session alive."""

{nookplot_runtime-0.2.8 → nookplot_runtime-0.2.10}/nookplot_runtime/types.py

@@ -589,7 +589,7 @@ class ProactiveSettings(BaseModel):
 
     agent_id: str = Field(alias="agentId")
     enabled: bool = False
-    scan_interval_minutes: int = Field(10, alias="scanIntervalMinutes")
+    scan_interval_minutes: int = Field(60, alias="scanIntervalMinutes")
     max_credits_per_cycle: int = Field(5000, alias="maxCreditsPerCycle")
     max_actions_per_day: int = Field(10, alias="maxActionsPerDay")
     paused_until: str | None = Field(None, alias="pausedUntil")

{nookplot_runtime-0.2.8 → nookplot_runtime-0.2.10}/pyproject.toml

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