nookplot-runtime 0.5.21__tar.gz → 0.5.23__tar.gz

{nookplot_runtime-0.5.21 → nookplot_runtime-0.5.23}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nookplot-runtime
-Version: 0.5.21
+Version: 0.5.23
 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.5.21 → nookplot_runtime-0.5.23}/nookplot_runtime/autonomous.py

@@ -283,6 +283,10 @@ class AutonomousAgent:
             return f"revision_requested:{data.get('agreementId', '')}"
         if signal_type == "review_received":
             return f"review_received:{data.get('agreementId', '')}"
+        # Webhook signals
+        if signal_type in ("webhook_received", "webhook.received"):
+            source = data.get("source", "")
+            return f"webhook:{source}:{int(time.time())}"
         return f"{signal_type}:{addr}:{data.get('channelId', '')}:{data.get('postCid', '')}"
 
     async def _handle_signal(self, data: dict[str, Any]) -> None:
@@ -436,6 +440,9 @@ class AutonomousAgent:
             self._broadcast("action_skipped", f"Received {data.get('rating', '?')}-star review on Agreement #{data.get('agreementId', '?')}", {
                 "signalType": signal_type, "agreementId": data.get("agreementId"), "rating": data.get("rating"),
             })
+        # ── Webhook signals ──
+        elif signal_type in ("webhook_received", "webhook.received"):
+            await self._handle_webhook_received(data)
         else:
             self._broadcast("action_skipped", f"⏭ Unhandled signal type: {signal_type}", {
                 "signalType": signal_type,
@@ -1111,6 +1118,46 @@ class AutonomousAgent:
                 "action": "revision_requested", "agreementId": agreement_id, "error": str(exc),
             })
 
+    # ── Webhook signal handler ──
+
+    async def _handle_webhook_received(self, data: dict[str, Any]) -> None:
+        """External webhook pushed an event — decide how to react."""
+        source = data.get("source", "unknown")
+        webhook_payload = data.get("payload", data.get("body", {}))
+        webhook_headers = data.get("headers", {})
+
+        try:
+            payload_preview = str(webhook_payload)[:500] if webhook_payload else "(empty)"
+
+            prompt = (
+                f"{UNTRUSTED_CONTENT_INSTRUCTION}\n\n"
+                "You received a webhook event from an external service.\n"
+                f"Source: {source}\n"
+                f"Payload:\n{wrap_untrusted(payload_preview, 'webhook payload')}\n\n"
+                "Decide what to do with this event. You can:\n"
+                "- egress_request: Make an outbound HTTP request (params: url, method, headers, body)\n"
+                "- execute_tool: Run a registered tool (params: toolName, args)\n"
+                "- send_message: Notify another agent (params: to, content)\n"
+                "- post: Share an update (params: body, community)\n"
+                "- ignore: Take no action\n\n"
+                "Format:\nACTION: <action_type>\nPARAMS: <json params>"
+            )
+
+            assert self._generate_response is not None
+            response = await self._generate_response(prompt)
+            text = (response or "").strip()
+
+            if text and not text.upper().startswith("IGNORE"):
+                await self._parse_and_execute_action(text)
+            else:
+                self._broadcast("action_skipped", f"⏭ Webhook from {source} — no action taken", {
+                    "signalType": "webhook_received", "source": source,
+                })
+        except Exception as exc:
+            self._broadcast("error", f"Webhook handling failed: {exc}", {
+                "action": "webhook_received", "source": source, "error": str(exc),
+            })
+
     # ── Bounty application/submission signal handlers ──
 
     async def _handle_bounty_application_submitted(self, data: dict[str, Any]) -> None:
@@ -1966,7 +2013,7 @@ class AutonomousAgent:
                 tx_hash = pub.get("txHash") if isinstance(pub, dict) else getattr(pub, "tx_hash", None)
                 result = {"cid": pub.get("cid") if isinstance(pub, dict) else getattr(pub, "cid", None), "txHash": tx_hash}
 
-            elif action_type == "create_post":
+            elif action_type in ("create_post", "publish"):
                 community = payload.get("community", "general")
                 title = payload.get("title") or (suggested_content[:100] if suggested_content else "Untitled")
                 body = suggested_content or payload.get("body", "")
@@ -2113,7 +2160,7 @@ class AutonomousAgent:
                     }
                 )
 
-            elif action_type == "gateway_commit":
+            elif action_type in ("gateway_commit", "commit_files"):
                 pid = payload.get("projectId")
                 files = payload.get("files")
                 msg = suggested_content or payload.get("message", "Autonomous commit")
@@ -2353,7 +2400,7 @@ class AutonomousAgent:
                 task_result = await self._runtime.projects.update_task(proj_id, tid, **kw)
                 result = task_result if isinstance(task_result, dict) else {"updated": True}
 
-            elif action_type == "find_matching_agents":
+            elif action_type in ("find_matching_agents", "find_agents"):
                 skills = payload.get("skills", [])
                 if not skills:
                     raise ValueError("find_matching_agents requires skills array")
@@ -2580,7 +2627,7 @@ class AutonomousAgent:
             elif action_type == "create_listing":
                 # Alias for list_service
                 prep = await self._runtime._http.request("POST", "/v1/prepare/service/list", payload)
-                relay = await self._sign_and_relay(prep)
+                relay = await self._runtime.memory._sign_and_relay(prep)
                 tx_hash = relay.get("txHash", "")
                 result = relay
 
@@ -2589,7 +2636,7 @@ class AutonomousAgent:
                 if not gid:
                     raise ValueError("approve_guild requires guildId")
                 prep = await self._runtime._http.request("POST", f"/v1/prepare/guild/{gid}/approve", {})
-                relay = await self._sign_and_relay(prep)
+                relay = await self._runtime.memory._sign_and_relay(prep)
                 tx_hash = relay.get("txHash", "")
                 result = relay
 
@@ -2598,7 +2645,7 @@ class AutonomousAgent:
                 if not gid:
                     raise ValueError("reject_guild requires guildId")
                 prep = await self._runtime._http.request("POST", f"/v1/prepare/guild/{gid}/reject", {})
-                relay = await self._sign_and_relay(prep)
+                relay = await self._runtime.memory._sign_and_relay(prep)
                 tx_hash = relay.get("txHash", "")
                 result = relay
 
@@ -2607,10 +2654,173 @@ class AutonomousAgent:
                 if not gid:
                     raise ValueError("leave_guild requires guildId")
                 prep = await self._runtime._http.request("POST", f"/v1/prepare/guild/{gid}/leave", {})
-                relay = await self._sign_and_relay(prep)
+                relay = await self._runtime.memory._sign_and_relay(prep)
                 tx_hash = relay.get("txHash", "")
                 result = relay
 
+            # ── Bounty access grant/deny ───────────────────────
+            elif action_type == "grant":
+                proj_id = payload.get("projectId")
+                bounty_id = payload.get("bountyId")
+                req_id = payload.get("requestId")
+                if not proj_id or not bounty_id or not req_id:
+                    raise ValueError("grant requires projectId, bountyId, requestId")
+                result = await self._runtime._http.request(
+                    "POST", f"/v1/projects/{proj_id}/bounties/{bounty_id}/grant-access",
+                    {"requestId": req_id},
+                )
+
+            elif action_type == "deny":
+                proj_id = payload.get("projectId")
+                bounty_id = payload.get("bountyId")
+                req_id = payload.get("requestId")
+                if not proj_id or not bounty_id or not req_id:
+                    raise ValueError("deny requires projectId, bountyId, requestId")
+                result = await self._runtime._http.request(
+                    "POST", f"/v1/projects/{proj_id}/bounties/{bounty_id}/deny-access",
+                    {"requestId": req_id},
+                )
+
+            # ── Team invitations ──────────────────────────────
+            elif action_type == "accept_invitation":
+                inv_id = payload.get("invitationId")
+                if not inv_id:
+                    raise ValueError("accept_invitation requires invitationId")
+                result = await self._runtime._http.request(
+                    "POST", f"/v1/teams/invitations/{inv_id}/accept", {},
+                )
+
+            elif action_type == "decline_invitation":
+                inv_id = payload.get("invitationId")
+                if not inv_id:
+                    raise ValueError("decline_invitation requires invitationId")
+                result = await self._runtime._http.request(
+                    "POST", f"/v1/teams/invitations/{inv_id}/decline", {},
+                )
+
+            # ── Service update ────────────────────────────────
+            elif action_type == "update_service":
+                listing_id = payload.get("listingId")
+                if not listing_id:
+                    raise ValueError("update_service requires listingId")
+                prep = await self._runtime._http.request(
+                    "POST", "/v1/prepare/service/update", payload,
+                )
+                relay = await self._runtime.memory._sign_and_relay(prep)
+                tx_hash = relay.get("txHash", "")
+                result = relay
+
+            # ── Additional bounty lifecycle ───────────────────
+            elif action_type == "approve_bounty_work":
+                bounty_id = payload.get("bountyId")
+                if not bounty_id:
+                    raise ValueError("approve_bounty_work requires bountyId")
+                prep = await self._runtime._http.request(
+                    "POST", f"/v1/prepare/bounty/{bounty_id}/approve", {},
+                )
+                relay = await self._runtime.memory._sign_and_relay(prep)
+                tx_hash = relay.get("txHash", "")
+                result = relay
+
+            elif action_type == "dispute_bounty_work":
+                bounty_id = payload.get("bountyId")
+                if not bounty_id:
+                    raise ValueError("dispute_bounty_work requires bountyId")
+                prep = await self._runtime._http.request(
+                    "POST", f"/v1/prepare/bounty/{bounty_id}/dispute", {},
+                )
+                relay = await self._runtime.memory._sign_and_relay(prep)
+                tx_hash = relay.get("txHash", "")
+                result = relay
+
+            elif action_type == "cancel_bounty":
+                bounty_id = payload.get("bountyId")
+                if not bounty_id:
+                    raise ValueError("cancel_bounty requires bountyId")
+                prep = await self._runtime._http.request(
+                    "POST", f"/v1/prepare/bounty/{bounty_id}/cancel", {},
+                )
+                relay = await self._runtime.memory._sign_and_relay(prep)
+                tx_hash = relay.get("txHash", "")
+                result = relay
+
+            elif action_type == "unclaim_bounty":
+                bounty_id = payload.get("bountyId")
+                if not bounty_id:
+                    raise ValueError("unclaim_bounty requires bountyId")
+                prep = await self._runtime._http.request(
+                    "POST", f"/v1/prepare/bounty/{bounty_id}/unclaim", {},
+                )
+                relay = await self._runtime.memory._sign_and_relay(prep)
+                tx_hash = relay.get("txHash", "")
+                result = relay
+
+            # ── Real World Actions ──────────────────────────────
+            elif action_type in ("egress_request", "http_request"):
+                # Outbound HTTP request via the egress proxy (0.15 credits)
+                target_url = payload.get("url", "")
+                http_method = (payload.get("method", "GET")).upper()
+                if not target_url:
+                    raise ValueError("egress_request requires url")
+                http_result = await self._runtime.tools.http_request(
+                    url=target_url,
+                    method=http_method,
+                    headers=payload.get("headers"),
+                    body=payload.get("body"),
+                    timeout=payload.get("timeout"),
+                    credential_service=payload.get("credentialService"),
+                )
+                result = http_result if isinstance(http_result, dict) else {"response": http_result}
+
+            elif action_type == "execute_tool":
+                # Execute a registered tool through the action registry
+                tool_name = payload.get("toolName") or payload.get("name", "")
+                tool_args = payload.get("args") or payload.get("input", {})
+                if not tool_name:
+                    raise ValueError("execute_tool requires toolName")
+                tool_result = await self._runtime.tools.execute_tool(tool_name, tool_args)
+                result = tool_result if isinstance(tool_result, dict) else {"output": tool_result}
+
+            elif action_type == "connect_mcp_server":
+                # Connect to an external MCP server
+                server_url = payload.get("serverUrl", "")
+                server_name = payload.get("serverName") or payload.get("name", "")
+                if not server_url or not server_name:
+                    raise ValueError("connect_mcp_server requires serverUrl and serverName")
+                mcp_result = await self._runtime.tools.connect_mcp_server(server_url, server_name)
+                result = mcp_result if isinstance(mcp_result, dict) else {"connected": True}
+
+            elif action_type == "disconnect_mcp_server":
+                server_id = payload.get("serverId", "")
+                if not server_id:
+                    raise ValueError("disconnect_mcp_server requires serverId")
+                await self._runtime.tools.disconnect_mcp_server(server_id)
+                result = {"disconnected": True, "serverId": server_id}
+
+            elif action_type in ("call_mcp_tool", "use_mcp_tool"):
+                # Call a tool from a connected MCP server — goes through action registry
+                mcp_tool_name = payload.get("toolName") or payload.get("name", "")
+                mcp_tool_args = payload.get("args") or payload.get("input", {})
+                if not mcp_tool_name:
+                    raise ValueError("call_mcp_tool requires toolName")
+                mcp_tool_result = await self._runtime.tools.execute_tool(mcp_tool_name, mcp_tool_args)
+                result = mcp_tool_result if isinstance(mcp_tool_result, dict) else {"output": mcp_tool_result}
+
+            elif action_type == "register_webhook":
+                # Register a webhook source for inbound events
+                source = payload.get("source") or payload.get("name", "")
+                if not source:
+                    raise ValueError("register_webhook requires source")
+                config: dict[str, Any] = {}
+                if payload.get("secret"):
+                    config["secret"] = payload["secret"]
+                if payload.get("signatureHeader"):
+                    config["signatureHeader"] = payload["signatureHeader"]
+                if payload.get("eventMapping"):
+                    config["eventMapping"] = payload["eventMapping"]
+                reg_result = await self._runtime.tools.register_webhook(source, config or None)
+                result = reg_result if isinstance(reg_result, dict) else {"registered": True}
+
             else:
                 self._broadcast("action_skipped", f"⏭ Unknown action: {action_type}", {
                     "action": action_type, "actionId": action_id,

{nookplot_runtime-0.5.21 → nookplot_runtime-0.5.23}/nookplot_runtime/client.py

@@ -1943,6 +1943,84 @@ class _ToolManager:
         data = await self._http.request("GET", "/v1/agents/me/mcp/tools")
         return data.get("data", [])
 
+    # ── Webhook Management ──
+
+    async def register_webhook(
+        self,
+        source: str,
+        config: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        """Register a webhook source so external services can push events."""
+        data = await self._http.request(
+            "POST",
+            "/v1/agents/me/webhooks",
+            {"source": source, "config": config or {}},
+        )
+        return data.get("data", {})
+
+    async def list_webhooks(self) -> list[dict[str, Any]]:
+        """List registered webhook sources."""
+        data = await self._http.request("GET", "/v1/agents/me/webhooks")
+        return data.get("data", [])
+
+    async def remove_webhook(self, source: str) -> None:
+        """Remove a webhook registration."""
+        await self._http.request(
+            "DELETE", f"/v1/agents/me/webhooks/{url_quote(source)}"
+        )
+
+    async def get_webhook_log(self, page: int = 0) -> list[dict[str, Any]]:
+        """Get webhook event log (recent deliveries)."""
+        data = await self._http.request(
+            "GET", f"/v1/agents/me/webhooks/log?page={page}"
+        )
+        return data.get("data", [])
+
+    # ── Egress Allowlist Management ──
+
+    async def get_egress_allowlist(self) -> list[dict[str, Any]]:
+        """Get the egress allowlist (domains this agent is allowed to call)."""
+        data = await self._http.request("GET", "/v1/agents/me/egress")
+        return data.get("allowlist", [])
+
+    async def add_egress_domain(
+        self,
+        domain: str,
+        max_requests_per_hour: int | None = None,
+    ) -> dict[str, Any]:
+        """Add or update a domain on the egress allowlist."""
+        payload: dict[str, Any] = {"domain": domain}
+        if max_requests_per_hour is not None:
+            payload["maxRequestsPerHour"] = max_requests_per_hour
+        return await self._http.request("PUT", "/v1/agents/me/egress", payload)
+
+    async def remove_egress_domain(self, domain: str) -> None:
+        """Remove a domain from the egress allowlist."""
+        await self._http.request(
+            "PUT", "/v1/agents/me/egress", {"domain": domain, "remove": True}
+        )
+
+    # ── Credential Management ──
+
+    async def store_credential(self, service: str, api_key: str) -> None:
+        """Store an encrypted API credential for use with egress requests."""
+        await self._http.request(
+            "POST",
+            "/v1/agents/me/credentials",
+            {"service": service, "apiKey": api_key},
+        )
+
+    async def list_credentials(self) -> list[dict[str, Any]]:
+        """List stored credential services (names only — keys are never exposed)."""
+        data = await self._http.request("GET", "/v1/agents/me/credentials")
+        return data.get("credentials", [])
+
+    async def remove_credential(self, service: str) -> None:
+        """Remove a stored credential."""
+        await self._http.request(
+            "DELETE", f"/v1/agents/me/credentials/{url_quote(service)}"
+        )
+
 
 # ============================================================
 #  Proactive Manager

{nookplot_runtime-0.5.21 → nookplot_runtime-0.5.23}/pyproject.toml

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