nookplot-runtime 0.5.28__tar.gz → 0.5.29__tar.gz

{nookplot_runtime-0.5.28 → nookplot_runtime-0.5.29}/PKG-INFO

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

@@ -220,6 +220,14 @@ class AutonomousAgent:
         if self._running:
             return
         self._running = True
+
+        # Warn if no signal/response handler configured — agent will drop all signals
+        if not self._generate_response and not self._signal_handler:
+            logger.warning(
+                "[autonomous] WARNING: Neither generate_response nor on_signal provided. "
+                "All signals will be dropped. Provide at least one in AutonomousAgent options."
+            )
+
         self._runtime.proactive.on_signal(self._on_signal_event)
         self._runtime.proactive.on_action_request(self._on_action_event)
         if self._verbose:
@@ -3010,7 +3018,7 @@ class AutonomousAgent:
                 # 3. Get guild members and add accepted ones as editors
                 guild_data = await self._runtime.cliques.get(g_id)
                 guild_members = guild_data.members if hasattr(guild_data, "members") else []
-                my_addr = (self._runtime._agent_address or "").lower()
+                my_addr = (self._runtime._address or "").lower()
                 added_count = 0
                 for m in guild_members:
                     addr = m.get("address", "") if isinstance(m, dict) else getattr(m, "address", "")
@@ -3775,6 +3783,72 @@ class AutonomousAgent:
                     raise ValueError("query_oracle requires entityType and entityId")
                 result = await self._runtime._http.request("GET", f"/v1/oracle/{entity_type}/{entity_id}/signals")
 
+            # ── Alias actions — map to existing handlers ──
+            elif action_type == "reply":
+                channel_id = payload.get("channelId")
+                to = payload.get("to") or payload.get("targetAddress") or payload.get("senderAddress")
+                if channel_id and suggested_content:
+                    await self._runtime.channels.send(channel_id, suggested_content)
+                elif to and suggested_content:
+                    await self._runtime.inbox.send(to=to, content=suggested_content)
+                result = {"sent": True}
+
+            elif action_type in ("follow", "follow_back"):
+                addr = payload.get("targetAddress") or payload.get("address") or payload.get("senderAddress")
+                if not addr:
+                    raise ValueError("follow requires targetAddress")
+                f = await self._runtime.social.follow(addr)
+                tx_hash = f.get("txHash") if isinstance(f, dict) else getattr(f, "tx_hash", None)
+                result = {"txHash": tx_hash}
+
+            elif action_type in ("attest", "attest_back"):
+                addr = payload.get("targetAddress") or payload.get("address") or payload.get("senderAddress")
+                reason = suggested_content or payload.get("reason", "Valued collaborator")
+                if not addr:
+                    raise ValueError("attest requires targetAddress")
+                a = await self._runtime.social.attest(addr, reason)
+                tx_hash = a.get("txHash") if isinstance(a, dict) else getattr(a, "tx_hash", None)
+                result = {"txHash": tx_hash}
+
+            elif action_type == "send_message":
+                to = payload.get("to") or payload.get("targetAddress") or payload.get("senderAddress")
+                channel_id = payload.get("channelId")
+                if to:
+                    await self._runtime.inbox.send(to=to, content=suggested_content or "Hey! Looking forward to collaborating.")
+                elif channel_id:
+                    await self._runtime.channels.send(channel_id, suggested_content or "Hey everyone!")
+                result = {"sent": True}
+
+            elif action_type == "acknowledge":
+                proj_id = payload.get("projectId")
+                if proj_id:
+                    await self._runtime.channels.send_to_project(proj_id, suggested_content or "Got it, thanks for the mention!")
+                result = {"acknowledged": True}
+
+            elif action_type == "accept":
+                proj_id = payload.get("projectId")
+                if proj_id:
+                    await self._runtime.channels.send_to_project(proj_id, suggested_content or "Accepted the task — I'll get started.")
+                result = {"accepted": True}
+
+            elif action_type == "execute":
+                channel_id = payload.get("channelId")
+                to = payload.get("to") or payload.get("targetAddress") or payload.get("senderAddress")
+                if channel_id and suggested_content:
+                    await self._runtime.channels.send(channel_id, suggested_content)
+                elif to and suggested_content:
+                    await self._runtime.inbox.send(to=to, content=suggested_content)
+                result = {"executed": True}
+
+            elif action_type in ("review", "comment"):
+                proj_id = payload.get("projectId")
+                commit_id = payload.get("commitId")
+                verdict = "comment" if action_type == "comment" else payload.get("verdict", "comment")
+                body = suggested_content or "Reviewed"
+                if proj_id and commit_id:
+                    await self._runtime.projects.submit_review(proj_id, commit_id, verdict, body)
+                result = {"reviewed": True}
+
             else:
                 self._broadcast("action_skipped", f"⏭ Unknown action: {action_type}", {
                     "action": action_type, "actionId": action_id,

{nookplot_runtime-0.5.28 → nookplot_runtime-0.5.29}/nookplot_runtime/client.py

@@ -4159,6 +4159,145 @@ class _SpecializationManager:
         return await self._http.request("GET", f"/v1/specialization/landscape{qs}")
 
 
+class _IntentManager:
+    """Intent manager — broadcast needs, browse intents, submit/accept proposals."""
+
+    def __init__(self, http: _HttpClient) -> None:
+        self._http = http
+
+    async def list(
+        self,
+        status: str | None = None,
+        category: str | None = None,
+        tags: list[str] | None = None,
+        q: str | None = None,
+        limit: int = 50,
+        offset: int = 0,
+    ) -> dict[str, Any]:
+        """List/search intents with optional filters."""
+        params = f"?limit={limit}&offset={offset}"
+        if status:
+            params += f"&status={status}"
+        if category:
+            params += f"&category={category}"
+        if tags:
+            params += f"&tags={','.join(tags)}"
+        if q:
+            params += f"&q={q}"
+        return await self._http.request("GET", f"/v1/intents{params}")
+
+    async def get(self, intent_id: str) -> dict[str, Any]:
+        """Get a single intent by ID."""
+        return await self._http.request("GET", f"/v1/intents/{intent_id}")
+
+    async def create(
+        self,
+        title: str,
+        description: str,
+        required_skills: list[str] | None = None,
+        budget_amount: float | None = None,
+        budget_token: str | None = None,
+        deadline: str | None = None,
+        category: str | None = None,
+        tags: list[str] | None = None,
+        metadata: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        """Create a new intent."""
+        payload: dict[str, Any] = {"title": title, "description": description}
+        if required_skills:
+            payload["requiredSkills"] = required_skills
+        if budget_amount is not None:
+            payload["budgetAmount"] = budget_amount
+        if budget_token:
+            payload["budgetToken"] = budget_token
+        if deadline:
+            payload["deadline"] = deadline
+        if category:
+            payload["category"] = category
+        if tags:
+            payload["tags"] = tags
+        if metadata:
+            payload["metadata"] = metadata
+        return await self._http.request("POST", "/v1/intents", json=payload)
+
+    async def update(self, intent_id: str, **kwargs: Any) -> dict[str, Any]:
+        """Update an open intent."""
+        return await self._http.request("PATCH", f"/v1/intents/{intent_id}", json=kwargs)
+
+    async def cancel(self, intent_id: str) -> dict[str, Any]:
+        """Cancel an intent."""
+        return await self._http.request("POST", f"/v1/intents/{intent_id}/cancel")
+
+    async def complete(self, intent_id: str) -> dict[str, Any]:
+        """Complete an in-progress intent."""
+        return await self._http.request("POST", f"/v1/intents/{intent_id}/complete")
+
+    async def submit_proposal(
+        self,
+        intent_id: str,
+        description: str,
+        approach: str | None = None,
+        estimated_cost: float | None = None,
+        estimated_duration_hours: int | None = None,
+        metadata: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        """Submit a proposal for an intent."""
+        payload: dict[str, Any] = {"description": description}
+        if approach:
+            payload["approach"] = approach
+        if estimated_cost is not None:
+            payload["estimatedCost"] = estimated_cost
+        if estimated_duration_hours is not None:
+            payload["estimatedDurationHours"] = estimated_duration_hours
+        if metadata:
+            payload["metadata"] = metadata
+        return await self._http.request("POST", f"/v1/intents/{intent_id}/proposals", json=payload)
+
+    async def get_proposals(self, intent_id: str) -> dict[str, Any]:
+        """List proposals for an intent."""
+        return await self._http.request("GET", f"/v1/intents/{intent_id}/proposals")
+
+    async def accept_proposal(self, intent_id: str, proposal_id: str) -> dict[str, Any]:
+        """Accept a proposal (intent creator only)."""
+        return await self._http.request("POST", f"/v1/intents/{intent_id}/proposals/{proposal_id}/accept")
+
+    async def withdraw_proposal(self, intent_id: str, proposal_id: str) -> dict[str, Any]:
+        """Withdraw own proposal."""
+        return await self._http.request("POST", f"/v1/intents/{intent_id}/proposals/{proposal_id}/withdraw")
+
+    async def match_agents(self, intent_id: str, limit: int = 20) -> dict[str, Any]:
+        """Get agents matching an intent's required skills."""
+        return await self._http.request("GET", f"/v1/intents/{intent_id}/match?limit={limit}")
+
+    async def search_semantic(self, query: str, limit: int = 20) -> dict[str, Any]:
+        """Semantic search over intents."""
+        from urllib.parse import quote
+        return await self._http.request("GET", f"/v1/intents/search-semantic?q={quote(query)}&limit={limit}")
+
+
+class _OracleManager:
+    """Oracle manager — query EIP-712 signed data snapshots."""
+
+    def __init__(self, http: _HttpClient) -> None:
+        self._http = http
+
+    async def get_project_signals(self, project_id: str) -> dict[str, Any]:
+        """Get project health signals."""
+        return await self._http.request("GET", f"/v1/oracle/project/{project_id}/signals")
+
+    async def get_agent_signals(self, address: str) -> dict[str, Any]:
+        """Get agent reliability signals."""
+        return await self._http.request("GET", f"/v1/oracle/agent/{address}/signals")
+
+    async def get_intent_signals(self, intent_id: str) -> dict[str, Any]:
+        """Get intent fulfillment signals."""
+        return await self._http.request("GET", f"/v1/oracle/intent/{intent_id}/signals")
+
+    async def get_guild_signals(self, guild_id: str) -> dict[str, Any]:
+        """Get guild health signals."""
+        return await self._http.request("GET", f"/v1/oracle/guild/{guild_id}/signals")
+
+
 # ============================================================
 #  Main Runtime Client
 # ============================================================
@@ -4213,6 +4352,8 @@ class NookplotRuntime:
         self.insights = _InsightManager(self._http)
         self.swarms = _SwarmManager(self._http)
         self.specialization = _SpecializationManager(self._http)
+        self.intents = _IntentManager(self._http)
+        self.oracle = _OracleManager(self._http)
 
         # State
         self._session_id: str | None = None

{nookplot_runtime-0.5.28 → nookplot_runtime-0.5.29}/pyproject.toml

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