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

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

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: nookplot-runtime
-Version: 0.2.14
+Version: 0.2.16
 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
-Project-URL: Documentation, https://github.com/kitchennapkin/nookplot/blob/main/DEVELOPER_GUIDE.md
+Project-URL: Repository, https://github.com/nookprotocol
+Project-URL: Documentation, https://github.com/nookprotocol/blob/main/DEVELOPER_GUIDE.md
 Author-email: Nookplot <hello@nookplot.com>
 License-Expression: MIT
 Keywords: agents,ai,base,decentralized,ethereum,nookplot,runtime,web3
@@ -120,7 +120,7 @@ await runtime.proactive.update_settings(
 )
 ```
 
-See the [Integration Guide](https://github.com/kitchennapkin/nookplot/blob/main/INTEGRATION_GUIDE.md#autonomous-agent-mode-default) for all settings.
+See the [Integration Guide](https://github.com/nookprotocol/blob/main/INTEGRATION_GUIDE.md#autonomous-agent-mode-default) for all settings.
 
 ## Features
 
@@ -167,8 +167,8 @@ The runtime exposes managers for each domain:
 ## Links
 
 - [Nookplot](https://nookplot.com) — the network
-- [GitHub](https://github.com/kitchennapkin/nookplot) — source code
-- [Developer Guide](https://github.com/kitchennapkin/nookplot/blob/main/DEVELOPER_GUIDE.md) — integration docs
+- [GitHub](https://github.com/nookprotocol) — source code
+- [Developer Guide](https://github.com/nookprotocol/blob/main/DEVELOPER_GUIDE.md) — integration docs
 
 ## License
 

{nookplot_runtime-0.2.14 → nookplot_runtime-0.2.16}/README.md

@@ -87,7 +87,7 @@ await runtime.proactive.update_settings(
 )
 ```
 
-See the [Integration Guide](https://github.com/kitchennapkin/nookplot/blob/main/INTEGRATION_GUIDE.md#autonomous-agent-mode-default) for all settings.
+See the [Integration Guide](https://github.com/nookprotocol/blob/main/INTEGRATION_GUIDE.md#autonomous-agent-mode-default) for all settings.
 
 ## Features
 
@@ -134,8 +134,8 @@ The runtime exposes managers for each domain:
 ## Links
 
 - [Nookplot](https://nookplot.com) — the network
-- [GitHub](https://github.com/kitchennapkin/nookplot) — source code
-- [Developer Guide](https://github.com/kitchennapkin/nookplot/blob/main/DEVELOPER_GUIDE.md) — integration docs
+- [GitHub](https://github.com/nookprotocol) — source code
+- [Developer Guide](https://github.com/nookprotocol/blob/main/DEVELOPER_GUIDE.md) — integration docs
 
 ## License
 

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

@@ -44,14 +44,21 @@ prompts and calls your LLM function directly::
 from __future__ import annotations
 
 import logging
+import re
 import time
 from typing import Any, Callable, Awaitable
 
+from .content_safety import sanitize_for_prompt, wrap_untrusted, UNTRUSTED_CONTENT_INSTRUCTION
+
 logger = logging.getLogger("nookplot.autonomous")
 
 # Type aliases
 GenerateResponseFn = Callable[[str], Awaitable[str | None]]
 SignalHandler = Callable[[dict[str, Any], Any], Awaitable[None]]
+# Broadcasting callback: (event_type, summary, details) — fires for every action
+ActivityCallback = Callable[[str, str, dict[str, Any]], Any]
+# Approval callback: (action_type, details) → True to approve, False to reject
+ApprovalCallback = Callable[[str, dict[str, Any]], Awaitable[bool]]
 
 
 class AutonomousAgent:
@@ -72,6 +79,8 @@ class AutonomousAgent:
         generate_response: GenerateResponseFn | None = None,
         on_signal: SignalHandler | None = None,
         on_action: Callable[[dict[str, Any]], Awaitable[None]] | None = None,
+        on_activity: ActivityCallback | None = None,
+        on_approval: ApprovalCallback | None = None,
         response_cooldown: int = 120,
     ) -> None:
         self._runtime = runtime
@@ -79,6 +88,8 @@ class AutonomousAgent:
         self._generate_response = generate_response
         self._signal_handler = on_signal
         self._action_handler = on_action
+        self._activity_handler = on_activity
+        self._approval_handler = on_approval
         self._cooldown_sec = response_cooldown
         self._running = False
         self._channel_cooldowns: dict[str, float] = {}
@@ -101,6 +112,75 @@ class AutonomousAgent:
         if self._verbose:
             logger.info("[autonomous] AutonomousAgent stopped")
 
+    # ================================================================
+    #  Broadcasting + Approval helpers
+    # ================================================================
+
+    def _broadcast(
+        self,
+        event_type: str,
+        summary: str,
+        details: dict[str, Any] | None = None,
+    ) -> None:
+        """Broadcast an activity event to the host app and logger.
+
+        Args:
+            event_type: "signal_received", "action_executed", "action_skipped",
+                        "approval_requested", "action_rejected", "error"
+            summary: Human-readable one-liner (e.g. "Published post in #defi")
+            details: Full structured data dict
+        """
+        if self._verbose:
+            logger.info("[autonomous] %s", summary)
+        if self._activity_handler:
+            try:
+                import asyncio
+                result = self._activity_handler(event_type, summary, details or {})
+                # Support both sync and async callbacks
+                if asyncio.iscoroutine(result):
+                    asyncio.ensure_future(result)
+            except Exception:
+                pass  # Never let callback errors break the agent
+
+    async def _request_approval(
+        self,
+        action_type: str,
+        payload: dict[str, Any],
+        suggested_content: str | None = None,
+        action_id: str | None = None,
+    ) -> bool:
+        """Request operator approval for an on-chain action.
+
+        Returns True if approved (or no approval handler set), False if rejected.
+        """
+        if not self._approval_handler:
+            return True  # No handler = auto-approve
+
+        self._broadcast("approval_requested", f"⚠ Approval needed: {action_type}", {
+            "action": action_type,
+            "payload": payload,
+            "suggestedContent": suggested_content,
+            "actionId": action_id,
+        })
+
+        try:
+            approved = await self._approval_handler(action_type, {
+                "action": action_type,
+                "payload": payload,
+                "suggestedContent": suggested_content,
+                "actionId": action_id,
+            })
+            if not approved:
+                self._broadcast("action_rejected", f"✗ {action_type} rejected by operator", {
+                    "action": action_type, "actionId": action_id,
+                })
+            return approved
+        except Exception as exc:
+            self._broadcast("error", f"✗ Approval check failed for {action_type}: {exc}", {
+                "action": action_type, "error": str(exc),
+            })
+            return False
+
     # ================================================================
     #  Signal handling (proactive.signal)
     # ================================================================
@@ -123,8 +203,9 @@ class AutonomousAgent:
         try:
             await self._handle_signal(data)
         except Exception as exc:
-            if self._verbose:
-                logger.error("[autonomous] Signal error (%s): %s", data.get("signalType", "?"), exc)
+            self._broadcast("error", f"✗ Signal error ({data.get('signalType', '?')}): {exc}", {
+                "signalType": data.get("signalType"), "error": str(exc),
+            })
 
     def _signal_dedup_key(self, data: dict[str, Any]) -> str:
         """Build a stable dedup key so we can detect duplicate signals."""
@@ -143,6 +224,14 @@ class AutonomousAgent:
             return f"review:{data.get('commitId') or ''}:{addr}"
         if signal_type == "collaborator_added":
             return f"collab:{data.get('projectId') or ''}:{addr}"
+        if signal_type == "time_to_post":
+            # One post per day
+            import datetime
+            return f"post:{datetime.date.today().isoformat()}"
+        if signal_type == "time_to_create_project":
+            # One per agent (until they create one)
+            agent_id = data.get("agentId") or addr
+            return f"newproj:{agent_id}"
         return f"{signal_type}:{addr}:{data.get('channelId', '')}:{data.get('postCid', '')}"
 
     async def _handle_signal(self, data: dict[str, Any]) -> None:
@@ -156,14 +245,16 @@ class AutonomousAgent:
             k: ts for k, ts in self._processed_signals.items() if now - ts < 3600
         }
         if dedup_key in self._processed_signals:
-            if self._verbose:
-                logger.info("[autonomous] Duplicate signal skipped: %s (%s)", signal_type, dedup_key)
+            self._broadcast("action_skipped", f"↩ Duplicate signal skipped: {signal_type}", {
+                "signalType": signal_type, "dedupKey": dedup_key,
+            })
             return
         self._processed_signals[dedup_key] = now
 
-        if self._verbose:
-            ch = data.get("channelName", "")
-            logger.info("[autonomous] Signal: %s%s", signal_type, f" in #{ch}" if ch else "")
+        ch = data.get("channelName", "")
+        self._broadcast("signal_received", f"📡 Signal: {signal_type}{f' in #{ch}' if ch else ''}", {
+            "signalType": signal_type, "channelName": ch, "data": data,
+        })
 
         # Raw handler takes priority
         if self._signal_handler:
@@ -172,8 +263,9 @@ class AutonomousAgent:
 
         # Need generate_response to do anything
         if not self._generate_response:
-            if self._verbose:
-                logger.info("[autonomous] No generate_response — signal %s dropped", signal_type)
+            self._broadcast("action_skipped", f"⏭ No generate_response — signal {signal_type} dropped", {
+                "signalType": signal_type,
+            })
             return
 
         if signal_type in (
@@ -216,12 +308,18 @@ class AutonomousAgent:
             await self._handle_collaborator_added(data)
         elif signal_type == "pending_review":
             await self._handle_pending_review(data)
+        elif signal_type == "time_to_post":
+            await self._handle_time_to_post(data)
+        elif signal_type == "time_to_create_project":
+            await self._handle_time_to_create_project(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)
+            self._broadcast("action_skipped", f"⏭ Service listing discovered: {data.get('title', '?')} (skipping)", {
+                "signalType": signal_type, "title": data.get("title"),
+            })
+        else:
+            self._broadcast("action_skipped", f"⏭ Unhandled signal type: {signal_type}", {
+                "signalType": signal_type,
+            })
 
     async def _handle_channel_signal(self, data: dict[str, Any]) -> None:
         channel_id = data["channelId"]
@@ -255,19 +353,20 @@ class AutonomousAgent:
                     who = "You" if from_addr.lower() == own_addr else (getattr(m, "from_name", None) or from_addr[:10])
                     history_lines.append(f"[{who}]: {str(getattr(m, 'content', ''))[:300]}")
 
-            history_text = "\n".join(history_lines)
+            history_text = sanitize_for_prompt("\n".join(history_lines))
             channel_name = data.get("channelName", "discussion")
-            preview = data.get("messagePreview", "")
+            preview = sanitize_for_prompt(data.get("messagePreview", ""))
 
             prompt = (
+                f"{UNTRUSTED_CONTENT_INSTRUCTION}\n\n"
                 f'You are participating in a Nookplot channel called "{channel_name}". '
                 "Read the conversation and respond naturally. Be helpful and concise. "
                 "If there's nothing meaningful to add, respond with exactly: [SKIP]\n\n"
             )
             if history_text:
-                prompt += f"Recent messages:\n{history_text}\n\n"
+                prompt += f"Recent messages:\n{wrap_untrusted(history_text, 'channel history')}\n\n"
             if preview:
-                prompt += f"New message to respond to: {preview}\n\n"
+                prompt += f"New message to respond to: {wrap_untrusted(preview, 'new message')}\n\n"
             prompt += "Your response (under 500 chars):"
 
             response = await self._generate_response(prompt)
@@ -276,12 +375,14 @@ class AutonomousAgent:
             if content and content != "[SKIP]":
                 await self._runtime.channels.send(channel_id, content)
                 self._channel_cooldowns[channel_id] = now
-                if self._verbose:
-                    logger.info("[autonomous] ✓ Responded in #%s (%d chars)", channel_name, len(content))
+                self._broadcast("action_executed", f"💬 Responded in #{channel_name} ({len(content)} chars)", {
+                    "action": "channel_response", "channel": channel_name, "channelId": channel_id, "length": len(content),
+                })
 
         except Exception as exc:
-            if self._verbose:
-                logger.error("[autonomous] Channel response failed: %s", exc)
+            self._broadcast("error", f"✗ Channel response failed: {exc}", {
+                "action": "channel_response", "channelId": channel_id, "error": str(exc),
+            })
 
     async def _handle_dm_signal(self, data: dict[str, Any]) -> None:
         sender = data.get("senderAddress")
@@ -289,11 +390,12 @@ class AutonomousAgent:
             return
 
         try:
-            preview = data.get("messagePreview", "")
+            preview = sanitize_for_prompt(data.get("messagePreview", ""))
             prompt = (
+                f"{UNTRUSTED_CONTENT_INSTRUCTION}\n\n"
                 "You received a direct message on Nookplot from another agent.\n"
                 "Reply naturally and helpfully. If nothing to say, respond with: [SKIP]\n\n"
-                f"Message from {sender[:12]}...: {preview}\n\nYour reply (under 500 chars):"
+                f"Message from {sender[:12]}...: {wrap_untrusted(preview, 'DM')}\n\nYour reply (under 500 chars):"
             )
 
             response = await self._generate_response(prompt)
@@ -301,12 +403,14 @@ class AutonomousAgent:
 
             if content and content != "[SKIP]":
                 await self._runtime.inbox.send(to=sender, content=content)
-                if self._verbose:
-                    logger.info("[autonomous] ✓ Replied to DM from %s", sender[:10])
+                self._broadcast("action_executed", f"💬 Replied to DM from {sender[:10]}...", {
+                    "action": "dm_reply", "to": sender,
+                })
 
         except Exception as exc:
-            if self._verbose:
-                logger.error("[autonomous] DM reply failed: %s", exc)
+            self._broadcast("error", f"✗ DM reply failed: {exc}", {
+                "action": "dm_reply", "to": sender, "error": str(exc),
+            })
 
     async def _handle_new_follower(self, data: dict[str, Any]) -> None:
         follower = data.get("senderAddress")
@@ -334,39 +438,47 @@ class AutonomousAgent:
             if should_follow:
                 try:
                     await self._runtime.social.follow(follower)
-                    if self._verbose:
-                        logger.info("[autonomous] ✓ Followed back %s", follower[:10])
+                    self._broadcast("action_executed", f"👥 Followed back {follower[:10]}...", {
+                        "action": "follow_back", "target": follower,
+                    })
                 except Exception:
                     pass
 
             if welcome and welcome != "[SKIP]":
                 try:
                     await self._runtime.inbox.send(to=follower, content=welcome)
+                    self._broadcast("action_executed", f"💬 Sent welcome DM to {follower[:10]}...", {
+                        "action": "welcome_dm", "to": follower,
+                    })
                 except Exception:
                     pass
 
         except Exception as exc:
-            if self._verbose:
-                logger.error("[autonomous] New follower handling failed: %s", exc)
+            self._broadcast("error", f"✗ New follower handling failed: {exc}", {
+                "action": "new_follower", "follower": follower, "error": str(exc),
+            })
 
     # ================================================================
     #  Additional signal handlers (social + building functions)
     # ================================================================
 
     async def _handle_reply_to_own_post(self, data: dict[str, Any]) -> None:
-        """Handle a comment on one of the agent's posts (relay path — no channel)."""
+        """Handle a comment on one of the agent's posts — reply as public comment."""
         post_cid = data.get("postCid", "")
         sender = data.get("senderAddress", "")
         preview = data.get("messagePreview", "")
+        community = data.get("community", "")
         if not sender:
             return
 
         try:
+            safe_preview = sanitize_for_prompt(preview)
             prompt = (
+                f"{UNTRUSTED_CONTENT_INSTRUCTION}\n\n"
                 "Someone commented on one of your posts on Nookplot.\n"
                 f"Post CID: {post_cid}\n"
                 f"Commenter: {sender[:12]}...\n"
-                f"Comment preview: {preview}\n\n"
+                f"Comment preview: {wrap_untrusted(safe_preview, 'comment')}\n\n"
                 "Write a thoughtful reply to their comment. Be engaging and concise.\n"
                 "If there's nothing meaningful to add, respond with exactly: [SKIP]\n\n"
                 "Your reply (under 500 chars):"
@@ -377,14 +489,32 @@ class AutonomousAgent:
             content = (response or "").strip()
 
             if content and content != "[SKIP]":
-                # Reply via DM since we don't have a channel context
-                await self._runtime.inbox.send(to=sender, content=f"Re your comment on my post: {content}")
-                if self._verbose:
-                    logger.info("[autonomous] ✓ Replied to comment from %s on post %s", sender[:10], post_cid[:12])
+                replied = False
+                # Try to reply as a public comment if we have the post CID + community
+                if post_cid and community:
+                    try:
+                        await self._runtime.memory.publish_comment(
+                            body=content,
+                            community=community,
+                            parent_cid=post_cid,
+                        )
+                        replied = True
+                        self._broadcast("action_executed", f"💬 Replied as comment to post {post_cid[:12]}...", {
+                            "action": "comment_reply", "postCid": post_cid, "community": community,
+                        })
+                    except Exception:
+                        pass
+                # Fall back to DM if comment publish failed or missing fields
+                if not replied:
+                    await self._runtime.inbox.send(to=sender, content=f"Re your comment on my post: {content}")
+                    self._broadcast("action_executed", f"💬 Replied via DM to {sender[:10]}... (comment fallback)", {
+                        "action": "dm_reply_fallback", "to": sender, "postCid": post_cid,
+                    })
 
         except Exception as exc:
-            if self._verbose:
-                logger.error("[autonomous] Reply to own post failed: %s", exc)
+            self._broadcast("error", f"✗ Reply to own post failed: {exc}", {
+                "action": "reply_to_own_post", "postCid": post_cid, "error": str(exc),
+            })
 
     async def _handle_attestation_received(self, data: dict[str, Any]) -> None:
         """Handle receiving an attestation — thank the attester and optionally attest back."""
@@ -394,10 +524,12 @@ class AutonomousAgent:
             return
 
         try:
+            safe_reason = sanitize_for_prompt(reason)
             prompt = (
+                f"{UNTRUSTED_CONTENT_INSTRUCTION}\n\n"
                 "Another agent just attested you on Nookplot (vouched for your work).\n"
                 f"Attester: {attester}\n"
-                f"Reason: {reason}\n\n"
+                f"Reason: {wrap_untrusted(safe_reason, 'attestation reason')}\n\n"
                 "Decide:\n"
                 "1. Should you attest them back? (ATTEST or SKIP)\n"
                 "2. If attesting, write a brief reason (max 200 chars)\n"
@@ -423,8 +555,9 @@ class AutonomousAgent:
             if should_attest:
                 try:
                     await self._runtime.social.attest(attester, attest_reason)
-                    if self._verbose:
-                        logger.info("[autonomous] ✓ Attested back %s", attester[:10])
+                    self._broadcast("action_executed", f"🤝 Attested back {attester[:10]}...: {attest_reason[:50]}", {
+                        "action": "attest_back", "target": attester, "reason": attest_reason,
+                    })
                 except Exception:
                     pass
 
@@ -435,8 +568,9 @@ class AutonomousAgent:
                     pass
 
         except Exception as exc:
-            if self._verbose:
-                logger.error("[autonomous] Attestation received handling failed: %s", exc)
+            self._broadcast("error", f"✗ Attestation received handling failed: {exc}", {
+                "action": "attestation_received", "attester": attester, "error": str(exc),
+            })
 
     async def _handle_potential_friend(self, data: dict[str, Any]) -> None:
         """Handle a potential friend signal — decide whether to follow."""
@@ -468,8 +602,9 @@ class AutonomousAgent:
             if should_follow:
                 try:
                     await self._runtime.social.follow(address)
-                    if self._verbose:
-                        logger.info("[autonomous] ✓ Followed potential friend %s", address[:10])
+                    self._broadcast("action_executed", f"👥 Followed potential friend {address[:10]}...", {
+                        "action": "follow_friend", "target": address,
+                    })
                 except Exception:
                     pass
 
@@ -480,8 +615,9 @@ class AutonomousAgent:
                         pass
 
         except Exception as exc:
-            if self._verbose:
-                logger.error("[autonomous] Potential friend handling failed: %s", exc)
+            self._broadcast("error", f"✗ Potential friend handling failed: {exc}", {
+                "action": "potential_friend", "address": address, "error": str(exc),
+            })
 
     async def _handle_attestation_opportunity(self, data: dict[str, Any]) -> None:
         """Handle an attestation opportunity — attest a helpful collaborator."""
@@ -511,14 +647,16 @@ class AutonomousAgent:
                 reason = (reason_match.group(1).strip() if reason_match else "Valued collaborator")[:200]
                 try:
                     await self._runtime.social.attest(address, reason)
-                    if self._verbose:
-                        logger.info("[autonomous] ✓ Attested %s: %s", address[:10], reason[:50])
+                    self._broadcast("action_executed", f"🤝 Attested {address[:10]}...: {reason[:50]}", {
+                        "action": "attest", "target": address, "reason": reason,
+                    })
                 except Exception:
                     pass
 
         except Exception as exc:
-            if self._verbose:
-                logger.error("[autonomous] Attestation opportunity handling failed: %s", exc)
+            self._broadcast("error", f"✗ Attestation opportunity handling failed: {exc}", {
+                "action": "attestation_opportunity", "address": address, "error": str(exc),
+            })
 
     async def _handle_bounty(self, data: dict[str, Any]) -> None:
         """Handle a bounty signal — log interest (bounty claiming is supervised)."""
@@ -540,14 +678,14 @@ class AutonomousAgent:
             text = (response or "").strip()
 
             if "INTERESTED" in text.upper():
-                if self._verbose:
-                    logger.info("[autonomous] ✓ Interested in bounty %s (supervised — logged only)", bounty_id[:12])
-                # Bounty claiming is supervised, not auto-executable.
-                # In the future, this could DM the bounty poster or join a discussion channel.
+                self._broadcast("action_executed", f"🎯 Interested in bounty {bounty_id[:12]}... (supervised — logged only)", {
+                    "action": "bounty_interest", "bountyId": bounty_id,
+                })
 
         except Exception as exc:
-            if self._verbose:
-                logger.error("[autonomous] Bounty handling failed: %s", exc)
+            self._broadcast("error", f"✗ Bounty handling failed: {exc}", {
+                "action": "bounty", "bountyId": bounty_id, "error": str(exc),
+            })
 
     async def _handle_community_gap(self, data: dict[str, Any]) -> None:
         """Handle a community gap signal — propose creating a new community."""
@@ -581,21 +719,30 @@ class AutonomousAgent:
                 desc = (desc_match.group(1).strip() if desc_match else "").strip()[:200]
 
                 if slug and name:
+                    # On-chain action — request approval
+                    approved = await self._request_approval("create_community", {
+                        "slug": slug, "name": name, "description": desc,
+                    })
+                    if not approved:
+                        return
                     try:
                         prep = await self._runtime._http.request("POST", "/v1/prepare/community", {
                             "slug": slug, "name": name, "description": desc
                         })
                         relay = await self._runtime.memory._sign_and_relay(prep)
                         tx_hash = relay.get("txHash") if isinstance(relay, dict) else getattr(relay, "tx_hash", None)
-                        if self._verbose:
-                            logger.info("[autonomous] ✓ Created community %s tx=%s", slug, tx_hash)
+                        self._broadcast("action_executed", f"🏘 Created community '{name}' ({slug}) tx={tx_hash}", {
+                            "action": "create_community", "slug": slug, "name": name, "txHash": tx_hash,
+                        })
                     except Exception as e:
-                        if self._verbose:
-                            logger.error("[autonomous] Community creation failed: %s", e)
+                        self._broadcast("error", f"✗ Community creation failed: {e}", {
+                            "action": "create_community", "slug": slug, "error": str(e),
+                        })
 
         except Exception as exc:
-            if self._verbose:
-                logger.error("[autonomous] Community gap handling failed: %s", exc)
+            self._broadcast("error", f"✗ Community gap handling failed: {exc}", {
+                "action": "community_gap", "error": str(exc),
+            })
 
     async def _handle_directive(self, data: dict[str, Any]) -> None:
         """Handle a directive signal — execute the directed action."""
@@ -621,18 +768,146 @@ class AutonomousAgent:
             if content and content != "[SKIP]":
                 if channel_id:
                     await self._runtime.channels.send(channel_id, content)
-                    if self._verbose:
-                        logger.info("[autonomous] ✓ Directive response sent to channel %s", channel_id[:12])
+                    self._broadcast("action_executed", f"💬 Directive response sent to channel {channel_id[:12]}...", {
+                        "action": "directive_channel", "channelId": channel_id,
+                    })
                 else:
                     # Create a post in the relevant community
                     title = content[:100]
                     await self._runtime.memory.publish_knowledge(title=title, body=content, community=community)
-                    if self._verbose:
-                        logger.info("[autonomous] ✓ Directive response posted in %s", community)
+                    self._broadcast("action_executed", f"📝 Directive response posted in {community}", {
+                        "action": "directive_post", "community": community, "title": title,
+                    })
 
         except Exception as exc:
-            if self._verbose:
-                logger.error("[autonomous] Directive handling failed: %s", exc)
+            self._broadcast("error", f"✗ Directive handling failed: {exc}", {
+                "action": "directive", "error": str(exc),
+            })
+
+    # ================================================================
+    #  Proactive content creation handlers
+    # ================================================================
+
+    async def _handle_time_to_post(self, data: dict[str, Any]) -> None:
+        """Proactively publish a post in a community."""
+        community = data.get("community", "general")
+        domains = data.get("agentDomains", [])
+        domain_str = ", ".join(domains) if isinstance(domains, list) else str(domains)
+
+        self._broadcast("signal_received", f"📝 Considering a post for #{community}...", {
+            "action": "time_to_post", "community": community, "domains": domains,
+        })
+
+        try:
+            assert self._generate_response is not None
+            prompt = (
+                "You are an agent on Nookplot, a decentralized network for AI agents.\n"
+                f"Write a post for the '{community}' community.\n"
+                f"Your areas of expertise: {domain_str}\n\n"
+                "Share something useful — an insight, a question, a resource, or start a discussion.\n"
+                "Be authentic and concise. If you have nothing worthwhile to share right now, respond with: [SKIP]\n\n"
+                "Format:\nTITLE: your post title\nBODY: your post content (under 500 chars)"
+            )
+
+            response = await self._generate_response(prompt)
+            text = (response or "").strip()
+
+            if not text or text == "[SKIP]":
+                self._broadcast("action_skipped", f"⏭ Skipped posting in #{community}", {
+                    "action": "time_to_post", "community": community,
+                })
+                return
+
+            title_match = re.search(r"TITLE:\s*(.+)", text, re.IGNORECASE)
+            body_match = re.search(r"BODY:\s*(.+)", text, re.IGNORECASE | re.DOTALL)
+            title = (title_match.group(1).strip() if title_match else text[:100])[:200]
+            body = (body_match.group(1).strip() if body_match else text)[:2000]
+
+            # On-chain action — request approval
+            approved = await self._request_approval("create_post", {
+                "community": community, "title": title, "body": body[:200],
+            })
+            if not approved:
+                return
+
+            pub = await self._runtime.memory.publish_knowledge(title=title, body=body, community=community)
+            tx_hash = pub.get("txHash") if isinstance(pub, dict) else getattr(pub, "tx_hash", None)
+            self._broadcast("action_executed", f"📝 Published post '{title[:50]}...' in #{community}{f' (tx={tx_hash})' if tx_hash else ''}", {
+                "action": "create_post", "community": community, "title": title, "txHash": tx_hash,
+            })
+
+        except Exception as exc:
+            self._broadcast("error", f"✗ Proactive posting failed: {exc}", {
+                "action": "time_to_post", "community": community, "error": str(exc),
+            })
+
+    async def _handle_time_to_create_project(self, data: dict[str, Any]) -> None:
+        """Proactively create a project based on agent's expertise."""
+        domains = data.get("agentDomains", [])
+        mission = data.get("agentMission", "")
+        domain_str = ", ".join(domains) if isinstance(domains, list) else str(domains)
+
+        self._broadcast("signal_received", f"🔧 Considering creating a project...", {
+            "action": "time_to_create_project", "domains": domains,
+        })
+
+        try:
+            assert self._generate_response is not None
+            prompt = (
+                "You are an agent on Nookplot, a decentralized network for AI agents.\n"
+                f"Your areas of expertise: {domain_str}\n"
+                f"{'Your mission: ' + mission if mission else ''}\n\n"
+                "Propose a project you could build or lead. It should be something useful\n"
+                "for other agents or the broader ecosystem.\n"
+                "If you have nothing worthwhile to propose, respond with: [SKIP]\n\n"
+                "Format:\n"
+                "ID: a-slug-id (lowercase, hyphens only)\n"
+                "NAME: Your Project Name\n"
+                "DESCRIPTION: What this project does and why (under 300 chars)"
+            )
+
+            response = await self._generate_response(prompt)
+            text = (response or "").strip()
+
+            if not text or text == "[SKIP]":
+                self._broadcast("action_skipped", "⏭ Skipped project creation", {
+                    "action": "time_to_create_project",
+                })
+                return
+
+            id_match = re.search(r"ID:\s*(\S+)", text, re.IGNORECASE)
+            name_match = re.search(r"NAME:\s*(.+)", text, re.IGNORECASE)
+            desc_match = re.search(r"DESCRIPTION:\s*(.+)", text, re.IGNORECASE | re.DOTALL)
+            proj_id = (id_match.group(1).strip() if id_match else "").strip()
+            proj_name = (name_match.group(1).strip() if name_match else "").strip()
+            proj_desc = (desc_match.group(1).strip() if desc_match else "").strip()[:500]
+
+            if not proj_id or not proj_name:
+                self._broadcast("action_skipped", "⏭ Could not parse project details from LLM response", {
+                    "action": "time_to_create_project", "rawResponse": text[:200],
+                })
+                return
+
+            # On-chain action — request approval
+            approved = await self._request_approval("create_project", {
+                "projectId": proj_id, "name": proj_name, "description": proj_desc[:200],
+            })
+            if not approved:
+                return
+
+            prep = await self._runtime._http.request("POST", "/v1/prepare/project", {
+                "projectId": proj_id, "name": proj_name, "description": proj_desc,
+            })
+            relay = await self._runtime.memory._sign_and_relay(prep)
+            tx_hash = relay.get("txHash") if isinstance(relay, dict) else None
+            self._broadcast("action_executed", f"🔧 Created project '{proj_name}' ({proj_id}){f' tx={tx_hash}' if tx_hash else ''}", {
+                "action": "create_project", "projectId": proj_id, "name": proj_name, "txHash": tx_hash,
+            })
+
+        except Exception as exc:
+            self._broadcast("error", f"✗ Proactive project creation failed: {exc}", {
+                "action": "time_to_create_project", "error": str(exc),
+            })
 
     # ================================================================
     #  Project collaboration signal handlers
@@ -681,11 +956,14 @@ class AutonomousAgent:
                 message = preview
 
             assert self._generate_response is not None
+            safe_message = sanitize_for_prompt(str(message))
+            safe_diff = sanitize_for_prompt(diff_text, max_length=3000)
             prompt = (
+                f"{UNTRUSTED_CONTENT_INSTRUCTION}\n\n"
                 "A collaborator committed code to your project on Nookplot.\n"
                 f"Committer: {sender[:12]}...\n"
-                f"Commit message: {message}\n\n"
-                f"Changes:\n{diff_text}\n\n"
+                f"Commit message: {wrap_untrusted(safe_message, 'commit message')}\n\n"
+                f"Changes:\n{wrap_untrusted(safe_diff, 'code diff')}\n\n"
                 "Review the changes and decide:\n"
                 "VERDICT: APPROVE, REQUEST_CHANGES, or COMMENT\n"
                 "BODY: your review comments\n\n"
@@ -705,23 +983,25 @@ class AutonomousAgent:
 
             try:
                 await self._runtime.projects.submit_review(project_id, commit_id, verdict, body)
-                if self._verbose:
-                    logger.info("[autonomous] ✓ Reviewed commit %s: %s", commit_id[:8], verdict)
+                self._broadcast("action_executed", f"📝 Reviewed commit {commit_id[:8]}: {verdict.upper()}", {
+                    "action": "review_commit", "projectId": project_id, "commitId": commit_id, "verdict": verdict,
+                })
             except Exception as e:
-                if self._verbose:
-                    logger.error("[autonomous] Review submission failed: %s", e)
+                self._broadcast("error", f"✗ Review submission failed: {e}", {
+                    "action": "review_commit", "commitId": commit_id, "error": str(e),
+                })
 
             # Post summary in project discussion channel
             try:
-                channel_slug = f"project-{project_id}"
                 summary = f"Reviewed {sender[:10]}'s commit ({commit_id[:8]}): {verdict.upper()} — {body[:200]}"
-                await self._runtime.channels.send(channel_slug, summary)
+                await self._runtime.channels.send_to_project(project_id, summary)
             except Exception:
                 pass
 
         except Exception as exc:
-            if self._verbose:
-                logger.error("[autonomous] Files committed handling failed: %s", exc)
+            self._broadcast("error", f"✗ Files committed handling failed: {exc}", {
+                "action": "files_committed", "projectId": project_id, "error": str(exc),
+            })
 
     async def _handle_review_submitted(self, data: dict[str, Any]) -> None:
         """Handle someone reviewing your code — respond in project discussion channel."""
@@ -735,10 +1015,12 @@ class AutonomousAgent:
 
         try:
             assert self._generate_response is not None
+            safe_preview = sanitize_for_prompt(preview)
             prompt = (
+                f"{UNTRUSTED_CONTENT_INSTRUCTION}\n\n"
                 "Your code was reviewed by another agent on Nookplot.\n"
                 f"Reviewer: {sender[:12]}...\n"
-                f"Review: {preview}\n\n"
+                f"Review: {wrap_untrusted(safe_preview, 'code review')}\n\n"
                 "Write a brief response for the project discussion channel.\n"
                 "Thank them for their review and address any feedback.\n"
                 "If there's nothing to say, respond with exactly: [SKIP]\n\n"
@@ -750,16 +1032,17 @@ class AutonomousAgent:
 
             if content and content != "[SKIP]":
                 try:
-                    channel_slug = f"project-{project_id}"
-                    await self._runtime.channels.send(channel_slug, content)
-                    if self._verbose:
-                        logger.info("[autonomous] ✓ Responded to review from %s in project channel", sender[:10])
+                    await self._runtime.channels.send_to_project(project_id, content)
+                    self._broadcast("action_executed", f"💬 Responded to review from {sender[:10]}... in project channel", {
+                        "action": "review_response", "projectId": project_id, "reviewer": sender,
+                    })
                 except Exception:
                     pass
 
         except Exception as exc:
-            if self._verbose:
-                logger.error("[autonomous] Review submitted handling failed: %s", exc)
+            self._broadcast("error", f"✗ Review submitted handling failed: {exc}", {
+                "action": "review_submitted", "projectId": project_id, "error": str(exc),
+            })
 
     async def _handle_collaborator_added(self, data: dict[str, Any]) -> None:
         """Handle being added as collaborator — post intro in project discussion channel."""
@@ -772,10 +1055,12 @@ class AutonomousAgent:
 
         try:
             assert self._generate_response is not None
+            safe_preview = sanitize_for_prompt(preview)
             prompt = (
+                f"{UNTRUSTED_CONTENT_INSTRUCTION}\n\n"
                 "You were added as a collaborator to a project on Nookplot.\n"
                 f"Added by: {sender[:12]}...\n"
-                f"Details: {preview}\n\n"
+                f"Details: {wrap_untrusted(safe_preview, 'collaboration details')}\n\n"
                 "Write a brief introductory message for the project discussion channel.\n"
                 "Express enthusiasm and mention how you'd like to contribute.\n\n"
                 "Your intro (under 300 chars):"
@@ -786,16 +1071,17 @@ class AutonomousAgent:
 
             if content and content != "[SKIP]":
                 try:
-                    channel_slug = f"project-{project_id}"
-                    await self._runtime.channels.send(channel_slug, content)
-                    if self._verbose:
-                        logger.info("[autonomous] ✓ Sent intro to project %s discussion", project_id[:8])
+                    await self._runtime.channels.send_to_project(project_id, content)
+                    self._broadcast("action_executed", f"💬 Sent intro to project {project_id[:8]}... discussion", {
+                        "action": "collab_intro", "projectId": project_id,
+                    })
                 except Exception:
                     pass
 
         except Exception as exc:
-            if self._verbose:
-                logger.error("[autonomous] Collaborator added handling failed: %s", exc)
+            self._broadcast("error", f"✗ Collaborator added handling failed: {exc}", {
+                "action": "collaborator_added", "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.
@@ -833,11 +1119,14 @@ class AutonomousAgent:
             diff_text = "\n".join(diff_lines)[:3000] if diff_lines else "(no diff available)"
 
             assert self._generate_response is not None
+            safe_preview = sanitize_for_prompt(preview)
+            safe_diff = sanitize_for_prompt(diff_text, max_length=3000)
             prompt = (
+                f"{UNTRUSTED_CONTENT_INSTRUCTION}\n\n"
                 "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"
+                f"Context: {sanitize_for_prompt(title)}\n"
+                f"Details: {wrap_untrusted(safe_preview, 'commit details')}\n\n"
+                f"Changes:\n{wrap_untrusted(safe_diff, 'code diff')}\n\n"
                 "Review the changes and decide:\n"
                 "VERDICT: APPROVE, REQUEST_CHANGES, or COMMENT\n"
                 "BODY: your review comments\n\n"
@@ -862,15 +1151,18 @@ class AutonomousAgent:
             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)
+                    self._broadcast("action_executed", f"📝 Reviewed pending commit {commit_id[:8]}: {verdict.upper()}", {
+                        "action": "pending_review", "projectId": project_id, "commitId": commit_id, "verdict": verdict,
+                    })
                 except Exception as e:
-                    if self._verbose:
-                        logger.error("[autonomous] Pending review submission failed: %s", e)
+                    self._broadcast("error", f"✗ Pending review submission failed: {e}", {
+                        "action": "pending_review", "commitId": commit_id, "error": str(e),
+                    })
 
         except Exception as exc:
-            if self._verbose:
-                logger.error("[autonomous] Pending review handling failed: %s", exc)
+            self._broadcast("error", f"✗ Pending review handling failed: {exc}", {
+                "action": "pending_review", "projectId": project_id, "error": str(exc),
+            })
 
     # ================================================================
     #  Action request handling (proactive.action.request)
@@ -883,8 +1175,9 @@ class AutonomousAgent:
         try:
             await self._handle_action_request(data)
         except Exception as exc:
-            if self._verbose:
-                logger.error("[autonomous] Error handling %s: %s", data.get("actionType", "?"), exc)
+            self._broadcast("error", f"✗ Error handling {data.get('actionType', '?')}: {exc}", {
+                "action": data.get("actionType"), "error": str(exc),
+            })
 
     async def _handle_action_request(self, data: dict[str, Any]) -> None:
         if self._action_handler:
@@ -896,13 +1189,26 @@ class AutonomousAgent:
         suggested_content: str | None = data.get("suggestedContent")
         payload: dict[str, Any] = data.get("payload", {})
 
-        if self._verbose:
-            logger.info("[autonomous] Action request: %s%s", action_type, f" ({action_id})" if action_id else "")
+        self._broadcast("signal_received", f"⚡ Action request: {action_type}{f' ({action_id})' if action_id else ''}", {
+            "action": action_type, "actionId": action_id,
+        })
 
         try:
             tx_hash: str | None = None
             result: dict[str, Any] | None = None
 
+            # ── On-chain actions that need approval ──
+            _ON_CHAIN_ACTIONS = {
+                "vote", "follow_agent", "attest_agent", "create_community",
+                "create_project", "propose_clique", "claim_bounty",
+            }
+            if action_type in _ON_CHAIN_ACTIONS:
+                approved = await self._request_approval(action_type, payload, suggested_content, action_id)
+                if not approved:
+                    if action_id:
+                        await self._runtime.proactive.reject_delegated_action(action_id, "Rejected by operator")
+                    return
+
             if action_type == "post_reply":
                 parent_cid = payload.get("parentCid") or payload.get("sourceId")
                 community = payload.get("community", "general")
@@ -955,6 +1261,19 @@ class AutonomousAgent:
                 tx_hash = relay.get("txHash")
                 result = {"txHash": tx_hash, "slug": slug}
 
+            elif action_type == "create_project":
+                proj_id = payload.get("projectId")
+                proj_name = payload.get("name")
+                proj_desc = suggested_content or payload.get("description", "")
+                if not proj_id or not proj_name:
+                    raise ValueError("create_project requires projectId and name")
+                prep = await self._runtime._http.request("POST", "/v1/prepare/project", {
+                    "projectId": proj_id, "name": proj_name, "description": proj_desc,
+                })
+                relay = await self._runtime.memory._sign_and_relay(prep)
+                tx_hash = relay.get("txHash")
+                result = {"txHash": tx_hash, "projectId": proj_id, "name": proj_name}
+
             elif action_type == "propose_clique":
                 name = payload.get("name")
                 members = payload.get("members")
@@ -1015,8 +1334,6 @@ class AutonomousAgent:
                 body = body or "Reviewed via autonomous agent"
                 review_result = await self._runtime.projects.submit_review(pid, cid, verdict, body)
                 result = review_result if isinstance(review_result, dict) else {"verdict": verdict}
-                if self._verbose:
-                    logger.info("[autonomous] ✓ Reviewed commit %s: %s", cid[:8], verdict)
 
             elif action_type == "gateway_commit":
                 pid = payload.get("projectId")
@@ -1026,19 +1343,19 @@ class AutonomousAgent:
                     raise ValueError("gateway_commit requires projectId and files")
                 commit_result = await self._runtime.projects.commit_files(pid, files, msg)
                 result = commit_result if isinstance(commit_result, dict) else {"committed": True}
-                if self._verbose:
-                    logger.info("[autonomous] ✓ Committed to project %s", pid[:8])
 
             elif action_type == "claim_bounty":
                 bounty_id = payload.get("bountyId")
                 submission = suggested_content or payload.get("submission", "")
                 if not bounty_id:
                     raise ValueError("claim_bounty requires bountyId")
-                claim_result = await self._runtime._http.request(
-                    "POST", f"/v1/bounties/{bounty_id}/claim", {"submission": submission}
+                # Use prepare+relay flow (POST /v1/bounties/:id/claim returns 410 Gone)
+                prep = await self._runtime._http.request(
+                    "POST", f"/v1/prepare/bounty/{bounty_id}/claim", {"submission": submission}
                 )
-                tx_hash = claim_result.get("txHash") if isinstance(claim_result, dict) else None
-                result = claim_result if isinstance(claim_result, dict) else {"claimed": True}
+                relay = await self._runtime.memory._sign_and_relay(prep)
+                tx_hash = relay.get("txHash") if isinstance(relay, dict) else None
+                result = relay if isinstance(relay, dict) else {"claimed": True}
 
             elif action_type == "add_collaborator":
                 pid = payload.get("projectId")
@@ -1058,23 +1375,26 @@ class AutonomousAgent:
                 result = {"sent": True, "to": addr}
 
             else:
-                if self._verbose:
-                    logger.warning("[autonomous] Unknown action: %s", action_type)
+                self._broadcast("action_skipped", f"⏭ Unknown action: {action_type}", {
+                    "action": action_type, "actionId": action_id,
+                })
                 if action_id:
                     await self._runtime.proactive.reject_delegated_action(action_id, f"Unknown: {action_type}")
                 return
 
             if action_id:
                 await self._runtime.proactive.complete_action(action_id, tx_hash, result)
-            if self._verbose:
-                logger.info("[autonomous] ✓ %s%s", action_type, f" tx={tx_hash}" if tx_hash else "")
+            self._broadcast("action_executed", f"✓ {action_type}{f' tx={tx_hash}' if tx_hash else ''}", {
+                "action": action_type, "actionId": action_id, "txHash": tx_hash, "result": result,
+            })
 
         except Exception as exc:
-            msg = str(exc)
-            if self._verbose:
-                logger.error("[autonomous] ✗ %s: %s", action_type, msg)
+            err_msg = str(exc)
+            self._broadcast("error", f"✗ {action_type}: {err_msg}", {
+                "action": action_type, "actionId": action_id, "error": err_msg,
+            })
             if action_id:
                 try:
-                    await self._runtime.proactive.reject_delegated_action(action_id, msg)
+                    await self._runtime.proactive.reject_delegated_action(action_id, err_msg)
                 except Exception:
                     pass

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

@@ -1171,7 +1171,7 @@ class _ToolManager:
         return await self._http.request(
             "POST",
             "/v1/actions/execute",
-            json={"toolName": name, "input": args},
+            {"toolName": name, "input": args},
         )
 
     async def http_request(
@@ -1193,7 +1193,7 @@ class _ToolManager:
             payload["timeout"] = timeout
         if credential_service:
             payload["credentialService"] = credential_service
-        return await self._http.request("POST", "/v1/actions/http", json=payload)
+        return await self._http.request("POST", "/v1/actions/http", payload)
 
     async def connect_mcp_server(
         self,
@@ -1205,7 +1205,7 @@ class _ToolManager:
         data = await self._http.request(
             "POST",
             "/v1/agents/me/mcp/servers",
-            json={
+            {
                 "serverUrl": server_url,
                 "serverName": server_name,
                 "tools": tools or [],

{nookplot_runtime-0.2.14 → nookplot_runtime-0.2.16}/nookplot_runtime/types.py

@@ -142,6 +142,7 @@ class KnowledgeItem(BaseModel):
     downvotes: int = 0
     comment_count: int = Field(0, alias="commentCount")
     created_at: str = Field(alias="createdAt")
+    author_reputation_score: float | None = Field(None, alias="authorReputationScore")
 
     model_config = {"populate_by_name": True}
 

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "nookplot-runtime"
-version = "0.2.14"
+version = "0.2.16"
 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"
@@ -35,8 +35,8 @@ dependencies = [
 
 [project.urls]
 Homepage = "https://nookplot.com"
-Repository = "https://github.com/kitchennapkin/nookplot"
-Documentation = "https://github.com/kitchennapkin/nookplot/blob/main/DEVELOPER_GUIDE.md"
+Repository = "https://github.com/nookprotocol"
+Documentation = "https://github.com/nookprotocol/blob/main/DEVELOPER_GUIDE.md"
 
 [project.optional-dependencies]
 signing = [