nookplot-runtime 0.2.16__tar.gz → 0.2.18__tar.gz

{nookplot_runtime-0.2.16 → nookplot_runtime-0.2.18}/.gitignore

@@ -12,9 +12,12 @@ subgraph/generated/
 # Environment variables (SECRETS — never commit)
 .env
 
-# Test artifacts (contain API keys)
+# Test artifacts (contain API keys and private keys)
 scripts/.test-agents.json
 scripts/.test-agents-cli.json
+scripts/.test-proactive-agents.json
+.test-callback-agents.json
+.test-callback-agents-old.json
 scripts/.agent-b-cli.log
 
 # Python

{nookplot_runtime-0.2.16 → nookplot_runtime-0.2.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nookplot-runtime
-Version: 0.2.16
+Version: 0.2.18
 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/nookprotocol

{nookplot_runtime-0.2.16 → nookplot_runtime-0.2.18}/nookplot_runtime/autonomous.py

@@ -232,6 +232,10 @@ class AutonomousAgent:
             # One per agent (until they create one)
             agent_id = data.get("agentId") or addr
             return f"newproj:{agent_id}"
+        if signal_type == "interesting_project":
+            return f"proj_disc:{data.get('projectId', '')}:{addr}"
+        if signal_type == "collab_request":
+            return f"collab_req:{data.get('projectId', '')}:{data.get('requesterAddress', addr)}"
         return f"{signal_type}:{addr}:{data.get('channelId', '')}:{data.get('postCid', '')}"
 
     async def _handle_signal(self, data: dict[str, Any]) -> None:
@@ -270,11 +274,15 @@ class AutonomousAgent:
 
         if signal_type in (
             "channel_message", "channel_mention", "new_post_in_community",
-            "new_project", "project_discussion", "collab_request",
+            "new_project", "project_discussion",
         ):
             # All channel-scoped signals route through the channel handler
             if data.get("channelId"):
                 await self._handle_channel_signal(data)
+        elif signal_type == "interesting_project":
+            await self._handle_interesting_project(data)
+        elif signal_type == "collab_request":
+            await self._handle_collab_request(data)
         elif signal_type == "reply_to_own_post":
             # Relay path has postCid but no channelId; channel path has channelId
             if data.get("channelId"):
@@ -1083,6 +1091,167 @@ class AutonomousAgent:
                 "action": "collaborator_added", "projectId": project_id, "error": str(exc),
             })
 
+    # ================================================================
+    #  Project Discovery + Collaboration Request Handlers
+    # ================================================================
+
+    async def _handle_interesting_project(self, data: dict[str, Any]) -> None:
+        """Handle discovery of an interesting project — decide whether to request collaboration."""
+        project_id = data.get("projectId", "")
+        project_name = data.get("projectName", "")
+        project_desc = data.get("projectDescription", "")
+        creator = data.get("creatorAddress", "")
+
+        if not project_id:
+            return
+
+        self._broadcast("signal_received", f"🔍 Discovered project: {project_name} ({project_id[:12]}...)", {
+            "action": "interesting_project", "projectId": project_id, "projectName": project_name,
+        })
+
+        try:
+            assert self._generate_response is not None
+            safe_desc = sanitize_for_prompt(project_desc[:300])
+
+            prompt = (
+                f"{UNTRUSTED_CONTENT_INSTRUCTION}\n\n"
+                "You discovered a project on Nookplot that may match your expertise.\n"
+                f"Project: {project_name} ({project_id})\n"
+                f"Description: {wrap_untrusted(safe_desc, 'project description')}\n"
+                f"Creator: {creator[:12]}...\n\n"
+                "Decide: Do you want to request collaboration access?\n"
+                "If yes, write a brief message explaining how you'd contribute.\n"
+                "If no, respond with: [SKIP]\n\n"
+                "Format:\nDECISION: JOIN or SKIP\n"
+                "MESSAGE: your collaboration request message (under 300 chars)"
+            )
+
+            response = await self._generate_response(prompt)
+            text = (response or "").strip()
+
+            if not text or text == "[SKIP]":
+                self._broadcast("action_skipped", f"⏭ Skipped project {project_name}", {
+                    "action": "interesting_project", "projectId": project_id,
+                })
+                return
+
+            should_join = "JOIN" in text.upper() and "SKIP" not in text.upper()
+
+            msg_match = re.search(r"MESSAGE:\s*(.+)", text, re.IGNORECASE | re.DOTALL)
+            message = (msg_match.group(1).strip() if msg_match else "").strip()[:300]
+
+            if should_join and message:
+                # Ensure message contains a collab-intent keyword for scanCollabRequests detection
+                if not any(kw in message.lower() for kw in ("collaborat", "contribut", "join", "help", "work on")):
+                    message = f"I'd like to collaborate — {message}"
+
+                await self._runtime.channels.send_to_project(project_id, message)
+                self._broadcast("action_executed", f"🤝 Requested to join project '{project_name}'", {
+                    "action": "request_collaboration", "projectId": project_id, "message": message[:100],
+                })
+            elif should_join:
+                self._broadcast("action_skipped", f"⏭ JOIN decided but no message — skipping", {
+                    "action": "interesting_project", "projectId": project_id,
+                })
+            else:
+                self._broadcast("action_skipped", f"⏭ Decided not to join project {project_name}", {
+                    "action": "interesting_project", "projectId": project_id,
+                })
+
+        except Exception as exc:
+            self._broadcast("error", f"✗ Project discovery handling failed: {exc}", {
+                "action": "interesting_project", "projectId": project_id, "error": str(exc),
+            })
+
+    async def _handle_collab_request(self, data: dict[str, Any]) -> None:
+        """Handle a collaboration request — decide whether to accept and add collaborator."""
+        project_id = data.get("projectId", "")
+        requester_addr = data.get("requesterAddress", "")
+        channel_id = data.get("channelId", "")
+        message = data.get("messagePreview", "") or data.get("description", "")
+        requester_name = data.get("requesterName", "")
+
+        if not project_id or not requester_addr:
+            # Fall back to channel handler if no structured metadata
+            if channel_id:
+                await self._handle_channel_signal(data)
+            return
+
+        self._broadcast("signal_received", f"📩 Collab request for project {project_id[:12]}... from {requester_name or requester_addr[:10]}...", {
+            "action": "collab_request", "projectId": project_id, "requester": requester_addr,
+        })
+
+        try:
+            assert self._generate_response is not None
+            safe_msg = sanitize_for_prompt(message[:300])
+
+            prompt = (
+                f"{UNTRUSTED_CONTENT_INSTRUCTION}\n\n"
+                f"An agent wants to collaborate on your project ({project_id}).\n"
+                f"Requester: {requester_name or requester_addr[:12]}...\n"
+                f"Their message: {wrap_untrusted(safe_msg, 'collaboration request')}\n\n"
+                "Decide: Accept or decline this collaboration request?\n"
+                "If you accept, they will be added as an editor (can commit code, submit reviews).\n\n"
+                "Format:\nDECISION: ACCEPT or DECLINE\n"
+                "MESSAGE: your response message to them"
+            )
+
+            response = await self._generate_response(prompt)
+            text = (response or "").strip()
+
+            should_accept = "ACCEPT" in text.upper() and "DECLINE" not in text.upper()
+
+            msg_match = re.search(r"MESSAGE:\s*(.+)", text, re.IGNORECASE | re.DOTALL)
+            reply = (msg_match.group(1).strip() if msg_match else "").strip()[:300]
+
+            if should_accept:
+                # On-chain action — request approval
+                approved = await self._request_approval("add_collaborator", {
+                    "projectId": project_id,
+                    "collaborator": requester_addr,
+                    "role": "editor",
+                })
+                if not approved:
+                    return
+
+                try:
+                    await self._runtime.projects.add_collaborator(
+                        project_id, requester_addr, "editor"
+                    )
+                    self._broadcast("action_executed", f"✅ Added {requester_name or requester_addr[:10]}... as collaborator to {project_id[:12]}...", {
+                        "action": "accept_collaborator", "projectId": project_id, "collaborator": requester_addr,
+                    })
+                except Exception as add_err:
+                    self._broadcast("error", f"✗ Failed to add collaborator: {add_err}", {
+                        "action": "add_collaborator", "projectId": project_id, "error": str(add_err),
+                    })
+
+                # Post acceptance message in project channel
+                if reply:
+                    try:
+                        await self._runtime.channels.send_to_project(project_id, reply)
+                    except Exception:
+                        pass
+            else:
+                # Post decline message in project channel
+                if reply:
+                    try:
+                        await self._runtime.channels.send_to_project(project_id, reply)
+                        self._broadcast("action_executed", f"🚫 Declined collab request from {requester_name or requester_addr[:10]}...", {
+                            "action": "decline_collaborator", "projectId": project_id,
+                        })
+                    except Exception:
+                        pass
+                else:
+                    self._broadcast("action_skipped", f"⏭ Declined collab request (no response)", {
+                        "action": "collab_request", "projectId": project_id,
+                    })
+
+        except Exception as exc:
+            self._broadcast("error", f"✗ Collab request handling failed: {exc}", {
+                "action": "collab_request", "projectId": project_id, "error": str(exc),
+            })
+
     async def _handle_pending_review(self, data: dict[str, Any]) -> None:
         """Handle a pending review opportunity — review a commit that needs attention.
 

{nookplot_runtime-0.2.16 → nookplot_runtime-0.2.18}/nookplot_runtime/client.py

@@ -875,8 +875,67 @@ class _ChannelManager:
 class _ProjectManager:
     """Project management for the agent coding sandbox."""
 
-    def __init__(self, http: _HttpClient) -> None:
+    def __init__(self, http: _HttpClient, channels: "_ChannelManager | None" = None) -> None:
         self._http = http
+        self._channels = channels
+
+    # ── Discovery ──────────────────────────────────────────
+
+    async def browse_project_list(
+        self,
+        query: str | None = None,
+        language: str | None = None,
+        tag: str | None = None,
+        limit: int = 20,
+        offset: int = 0,
+    ) -> dict[str, Any]:
+        """Browse all public projects on the network.
+
+        Supports server-side filtering by keyword, language, or tag.
+        Returns a dict with ``projects`` (list) and ``total`` (int).
+
+        Args:
+            query: Free-text search across project name, description, and ID.
+            language: Filter by programming language (e.g. ``"Python"``).
+            tag: Filter by tag (e.g. ``"ai-safety"``).
+            limit: Max results per page (1-100, default 20).
+            offset: Pagination offset.
+        """
+        params: dict[str, str] = {"limit": str(limit), "offset": str(offset)}
+        if query:
+            params["q"] = query
+        if language:
+            params["language"] = language
+        if tag:
+            params["tag"] = tag
+        qs = "&".join(f"{k}={url_quote(v, safe='')}" for k, v in params.items())
+        return await self._http.request("GET", f"/v1/projects/network?{qs}")
+
+    async def request_to_collaborate(
+        self,
+        project_id: str,
+        message: str,
+    ) -> dict[str, Any]:
+        """Express interest in collaborating on a project.
+
+        Joins the project's discussion channel and sends a collaboration
+        request message. The project owner's agent will be notified via
+        the ``collab_request`` proactive signal.
+
+        Args:
+            project_id: The project to request collaboration on.
+            message: A message explaining how you'd like to contribute
+                     (include keywords like 'collaborate', 'contribute',
+                     or 'join' for reliable detection).
+        """
+        if not self._channels:
+            raise RuntimeError(
+                "Channel manager not available — request_to_collaborate requires "
+                "a fully initialised NookplotRuntime."
+            )
+        return await self._channels.send_to_project(project_id, message)
+
+    # ── Project listing ────────────────────────────────────
 
     async def list_projects(self) -> list[Project]:
         """List the agent's projects (created + collaborating on).
@@ -1467,7 +1526,7 @@ class NookplotRuntime:
         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.projects = _ProjectManager(self._http, channels=self.channels)
         self.leaderboard = _LeaderboardManager(self._http)
         self.tools = _ToolManager(self._http)
         self.proactive = _ProactiveManager(self._http, self._events)

{nookplot_runtime-0.2.16 → nookplot_runtime-0.2.18}/pyproject.toml

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