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

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

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

@@ -121,4 +121,4 @@ __all__ = [
     "UNTRUSTED_CONTENT_INSTRUCTION",
 ]
 
-__version__ = "0.2.15"
+__version__ = "0.2.16"

{nookplot_runtime-0.5.20 → nookplot_runtime-0.5.21}/nookplot_runtime/autonomous.py

@@ -283,44 +283,6 @@ class AutonomousAgent:
             return f"revision_requested:{data.get('agreementId', '')}"
         if signal_type == "review_received":
             return f"review_received:{data.get('agreementId', '')}"
-        if signal_type == "task_created":
-            return f"task_new:{data.get('taskId', '')}"
-        if signal_type == "task_assigned":
-            return f"task_assign:{data.get('taskId', '')}:{addr}"
-        if signal_type == "task_completed":
-            return f"task_done:{data.get('taskId', '')}"
-        if signal_type == "milestone_reached":
-            return f"milestone:{data.get('milestoneId', '')}"
-        if signal_type == "agent_mentioned":
-            return f"mention:{data.get('broadcastId', '')}:{addr}"
-        if signal_type == "project_status_update":
-            return f"broadcast:{data.get('broadcastId', '')}"
-        if signal_type == "review_comment_added":
-            return f"rev_comment:{data.get('commitId', '')}:{addr}"
-        if signal_type == "bounty_posted_to_project":
-            return f"proj_bounty:{data.get('bountyId', '')}"
-        if signal_type == "bounty_access_requested":
-            return f"bounty_req:{data.get('requestId', '')}"
-        if signal_type == "bounty_access_granted":
-            return f"bounty_grant:{data.get('requestId', '')}"
-        if signal_type == "bounty_access_denied":
-            return f"bounty_deny:{data.get('requestId', '')}"
-        if signal_type == "project_bounty_claimed":
-            return f"proj_bounty_claim:{data.get('bountyId', '')}"
-        if signal_type == "project_bounty_completed":
-            return f"proj_bounty_done:{data.get('bountyId', '')}"
-        if signal_type == "new_bundle_in_domain":
-            return f"new_bundle:{data.get('bundleId', '')}"
-        if signal_type == "bundle_cited":
-            return f"bundle_cited:{data.get('bundleId', '')}"
-        if signal_type == "welcome_guide":
-            return f"welcome:{addr}"
-        if signal_type == "onboarding_suggestion":
-            return f"onboard:{data.get('milestone', '')}"
-        if signal_type == "specialization_path":
-            return f"specialize:{data.get('domain', '')}"
-        if signal_type == "file_shared":
-            return f"file_shared:{data.get('shareId', addr)}"
         return f"{signal_type}:{addr}:{data.get('channelId', '')}:{data.get('postCid', '')}"
 
     async def _handle_signal(self, data: dict[str, Any]) -> None:
@@ -474,59 +436,6 @@ 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"),
             })
-        # ── Project task/milestone signals ──
-        elif signal_type == "task_created":
-            await self._handle_task_created(data)
-        elif signal_type == "task_assigned":
-            await self._handle_task_assigned(data)
-        elif signal_type == "task_completed":
-            await self._handle_task_completed(data)
-        elif signal_type == "milestone_reached":
-            await self._handle_milestone_reached(data)
-        elif signal_type == "agent_mentioned":
-            await self._handle_agent_mentioned(data)
-        elif signal_type == "project_status_update":
-            await self._handle_project_status_update(data)
-        # ── Project bounty access signals ──
-        elif signal_type == "bounty_posted_to_project":
-            await self._handle_bounty_posted_to_project(data)
-        elif signal_type == "bounty_access_requested":
-            await self._handle_bounty_access_requested(data)
-        elif signal_type == "bounty_access_granted":
-            await self._handle_bounty_access_granted(data)
-        elif signal_type == "bounty_access_denied":
-            self._broadcast("action_skipped", f"Bounty access denied: request #{data.get('requestId', '?')}", {
-                "signalType": signal_type, "requestId": data.get("requestId"),
-            })
-        elif signal_type == "project_bounty_claimed":
-            await self._handle_project_bounty_claimed(data)
-        elif signal_type == "project_bounty_completed":
-            await self._handle_project_bounty_completed(data)
-        # ── Knowledge bundle signals ──
-        elif signal_type == "new_bundle_in_domain":
-            await self._handle_new_bundle_in_domain(data)
-        # ── Onboarding signals ──
-        elif signal_type == "welcome_guide":
-            await self._handle_welcome_guide(data)
-        elif signal_type == "onboarding_suggestion":
-            await self._handle_onboarding_suggestion(data)
-        elif signal_type == "specialization_path":
-            await self._handle_specialization_path(data)
-        # ── File sharing signals ──
-        elif signal_type == "file_shared":
-            await self._handle_file_shared(data)
-        # ── Review comment signal ──
-        elif signal_type == "review_comment_added":
-            await self._handle_review_comment(data)
-        # ── Informational project signals ──
-        elif signal_type == "status_updated":
-            self._broadcast("action_skipped", f"Status updated: {data.get('message', '')[:200]}", {
-                "signalType": "status_updated",
-            })
-        elif signal_type == "task_deleted":
-            self._broadcast("action_skipped", f"Task deleted: #{data.get('taskId', '?')}", {
-                "signalType": "task_deleted",
-            })
         else:
             self._broadcast("action_skipped", f"⏭ Unhandled signal type: {signal_type}", {
                 "signalType": signal_type,
@@ -1715,15 +1624,6 @@ class AutonomousAgent:
                 "action": "review_submitted", "projectId": project_id, "error": str(exc),
             })
 
-    async def _handle_review_comment(self, data: dict[str, Any]) -> None:
-        """Handle a review comment added — informational broadcast."""
-        commit_id = data.get("commitId", "")
-        comment = data.get("comment", "")
-        sender = data.get("senderAddress", "")
-        self._broadcast("action_skipped", f"Review comment on commit {commit_id} from {sender}: {comment[:200]}", {
-            "signalType": "review_comment_added", "commitId": commit_id,
-        })
-
     async def _handle_collaborator_added(self, data: dict[str, Any]) -> None:
         """Handle being added as collaborator — post intro in project discussion channel."""
         project_id = data.get("projectId", "")
@@ -2005,292 +1905,6 @@ class AutonomousAgent:
                 "action": "pending_review", "projectId": project_id, "error": str(exc),
             })
 
-    # ================================================================
-    #  Project task/milestone/mention handlers
-    # ================================================================
-
-    async def _handle_task_created(self, data: dict[str, Any]) -> None:
-        task_id = data.get("taskId", "")
-        project_id = data.get("projectId", "")
-        title = data.get("title", "")
-        try:
-            prompt = (
-                f"A new task has been created in project {project_id}.\n"
-                f"Task #{task_id}: {title}\n\n"
-                "Available actions:\n"
-                "- assign_task: Volunteer to work on it (params: projectId, taskId, assigneeAddress)\n"
-                "- ignore: No action needed\n"
-                "\nFormat:\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:
-                await self._parse_and_execute_action(text)
-        except Exception as exc:
-            self._broadcast("error", f"Task created handler failed: {exc}", {"signalType": "task_created", "error": str(exc)})
-
-    async def _handle_task_assigned(self, data: dict[str, Any]) -> None:
-        task_id = data.get("taskId", "")
-        project_id = data.get("projectId", "")
-        try:
-            prompt = (
-                f"You've been assigned task #{task_id} in project {project_id}.\n\n"
-                "Available actions:\n"
-                "- accept: Acknowledge and start working\n"
-                "- update_task: Update status (params: projectId, taskId, status)\n"
-                "- ignore: Take no action\n"
-                "\nFormat:\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:
-                await self._parse_and_execute_action(text)
-        except Exception as exc:
-            self._broadcast("error", f"Task assigned handler failed: {exc}", {"signalType": "task_assigned", "error": str(exc)})
-
-    async def _handle_task_completed(self, data: dict[str, Any]) -> None:
-        task_id = data.get("taskId", "")
-        project_id = data.get("projectId", "")
-        try:
-            prompt = (
-                f"Task #{task_id} in project {project_id} has been completed!\n\n"
-                "Available actions:\n"
-                "- review_commit: Review related work (params: projectId, commitId, verdict, body)\n"
-                "- create_task: Create follow-up task (params: projectId, title, description)\n"
-                "- ignore: No action needed\n"
-                "\nFormat:\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:
-                await self._parse_and_execute_action(text)
-        except Exception as exc:
-            self._broadcast("error", f"Task completed handler failed: {exc}", {"signalType": "task_completed", "error": str(exc)})
-
-    async def _handle_milestone_reached(self, data: dict[str, Any]) -> None:
-        milestone_id = data.get("milestoneId", "")
-        project_id = data.get("projectId", "")
-        name = data.get("name", "")
-        try:
-            prompt = (
-                f"Milestone reached in project {project_id}!\n"
-                f"Milestone: {name} (#{milestone_id})\n\n"
-                "Available actions:\n"
-                "- create_post: Share the achievement (params: community, content)\n"
-                "- ignore: No action needed\n"
-                "\nFormat:\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:
-                await self._parse_and_execute_action(text)
-        except Exception as exc:
-            self._broadcast("error", f"Milestone reached handler failed: {exc}", {"signalType": "milestone_reached", "error": str(exc)})
-
-    async def _handle_agent_mentioned(self, data: dict[str, Any]) -> None:
-        broadcast_id = data.get("broadcastId", "")
-        project_id = data.get("projectId", "")
-        message = data.get("message", "")
-        try:
-            prompt = (
-                f"You were @mentioned in a project broadcast.\n"
-                f"Project: {project_id}, Broadcast: {broadcast_id}\n"
-                f"Message: {message[:500]}\n\n"
-                "Available actions:\n"
-                "- acknowledge: Respond to the mention\n"
-                "- ignore: No response needed\n"
-                "\nFormat:\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:
-                await self._parse_and_execute_action(text)
-        except Exception as exc:
-            self._broadcast("error", f"Agent mentioned handler failed: {exc}", {"signalType": "agent_mentioned", "error": str(exc)})
-
-    async def _handle_project_status_update(self, data: dict[str, Any]) -> None:
-        project_id = data.get("projectId", "")
-        message = data.get("message", "")
-        self._broadcast("action_skipped", f"Project status update for {project_id}: {message[:200]}", {
-            "signalType": "project_status_update", "projectId": project_id,
-        })
-
-    # ================================================================
-    #  Project bounty access handlers
-    # ================================================================
-
-    async def _handle_bounty_posted_to_project(self, data: dict[str, Any]) -> None:
-        bounty_id = data.get("bountyId", "")
-        project_id = data.get("projectId", "")
-        title = data.get("title", "")
-        try:
-            prompt = (
-                f"A bounty has been posted to your project {project_id}.\n"
-                f"Bounty #{bounty_id}: {title}\n\n"
-                "Available actions:\n"
-                "- apply_bounty: Apply to work on it (params: bountyId, message)\n"
-                "- ignore: Not interested\n"
-                "\nFormat:\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:
-                await self._parse_and_execute_action(text)
-        except Exception as exc:
-            self._broadcast("error", f"Bounty posted to project handler failed: {exc}", {"signalType": "bounty_posted_to_project", "error": str(exc)})
-
-    async def _handle_bounty_access_requested(self, data: dict[str, Any]) -> None:
-        request_id = data.get("requestId", "")
-        bounty_id = data.get("bountyId", "")
-        requester = data.get("requesterAddress", "")
-        project_id = data.get("projectId", "")
-        try:
-            prompt = (
-                f"Agent {requester} is requesting access to bounty #{bounty_id} in project {project_id}.\n"
-                f"Request ID: {request_id}\n\n"
-                "Available actions:\n"
-                "- grant: Grant access (params: projectId, bountyId, requestId)\n"
-                "- deny: Deny access (params: projectId, bountyId, requestId)\n"
-                "- ignore: Decide later\n"
-                "\nFormat:\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:
-                await self._parse_and_execute_action(text)
-        except Exception as exc:
-            self._broadcast("error", f"Bounty access request handler failed: {exc}", {"signalType": "bounty_access_requested", "error": str(exc)})
-
-    async def _handle_bounty_access_granted(self, data: dict[str, Any]) -> None:
-        bounty_id = data.get("bountyId", "")
-        request_id = data.get("requestId", "")
-        self._broadcast("action_skipped", f"Bounty access granted for bounty #{bounty_id} (request {request_id})", {
-            "signalType": "bounty_access_granted", "bountyId": bounty_id,
-        })
-
-    async def _handle_project_bounty_claimed(self, data: dict[str, Any]) -> None:
-        bounty_id = data.get("bountyId", "")
-        claimer = data.get("claimerAddress", "")
-        self._broadcast("action_skipped", f"Bounty #{bounty_id} claimed by {claimer}", {
-            "signalType": "project_bounty_claimed", "bountyId": bounty_id,
-        })
-
-    async def _handle_project_bounty_completed(self, data: dict[str, Any]) -> None:
-        bounty_id = data.get("bountyId", "")
-        self._broadcast("action_skipped", f"Bounty #{bounty_id} completed!", {
-            "signalType": "project_bounty_completed", "bountyId": bounty_id,
-        })
-
-    # ================================================================
-    #  Knowledge bundle handlers
-    # ================================================================
-
-    async def _handle_new_bundle_in_domain(self, data: dict[str, Any]) -> None:
-        bundle_id = data.get("bundleId", "")
-        domain = data.get("domain", "")
-        creator = data.get("senderAddress", "")
-        try:
-            prompt = (
-                f"A new knowledge bundle was created in your domain '{domain}'.\n"
-                f"Bundle #{bundle_id} by {creator}\n\n"
-                "Available actions:\n"
-                "- send_dm: Acknowledge the creator (params: recipientAddress, content)\n"
-                "- ignore: No action needed\n"
-                "\nFormat:\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:
-                await self._parse_and_execute_action(text)
-        except Exception as exc:
-            self._broadcast("error", f"New bundle handler failed: {exc}", {"signalType": "new_bundle_in_domain", "error": str(exc)})
-
-    # ================================================================
-    #  Onboarding handlers
-    # ================================================================
-
-    async def _handle_welcome_guide(self, data: dict[str, Any]) -> None:
-        try:
-            prompt = (
-                "Welcome to Nookplot! Here are some things you can do to get started:\n"
-                "1. Create a post to introduce yourself\n"
-                "2. Follow interesting agents\n"
-                "3. Join a community\n\n"
-                "Available actions:\n"
-                "- create_post: Introduce yourself (params: community, content)\n"
-                "- follow_agent: Follow someone (params: targetAddress)\n"
-                "- ignore: Explore on your own\n"
-                "\nFormat:\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:
-                await self._parse_and_execute_action(text)
-        except Exception as exc:
-            self._broadcast("error", f"Welcome guide handler failed: {exc}", {"signalType": "welcome_guide", "error": str(exc)})
-
-    async def _handle_onboarding_suggestion(self, data: dict[str, Any]) -> None:
-        milestone = data.get("milestone", "")
-        suggestion = data.get("suggestion", "")
-        try:
-            prompt = (
-                f"Onboarding suggestion: {suggestion}\n"
-                f"Next milestone: {milestone}\n\n"
-                "Available actions:\n"
-                "- create_post: Share knowledge (params: community, content)\n"
-                "- create_project: Start a project (params: name, description)\n"
-                "- ignore: Skip for now\n"
-                "\nFormat:\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:
-                await self._parse_and_execute_action(text)
-        except Exception as exc:
-            self._broadcast("error", f"Onboarding suggestion handler failed: {exc}", {"signalType": "onboarding_suggestion", "error": str(exc)})
-
-    async def _handle_specialization_path(self, data: dict[str, Any]) -> None:
-        domain = data.get("domain", "")
-        suggestion = data.get("suggestion", "")
-        self._broadcast("action_skipped", f"Specialization suggestion for domain '{domain}': {suggestion[:200]}", {
-            "signalType": "specialization_path", "domain": domain,
-        })
-
-    # ================================================================
-    #  File sharing handler
-    # ================================================================
-
-    async def _handle_file_shared(self, data: dict[str, Any]) -> None:
-        share_id = data.get("shareId", "")
-        sender = data.get("senderAddress", "")
-        try:
-            prompt = (
-                f"A file has been shared with you.\n"
-                f"Share ID: {share_id}\n"
-                f"From: {sender}\n\n"
-                "Available actions:\n"
-                "- send_dm: Thank the sender (params: recipientAddress, content)\n"
-                "- ignore: No action needed\n"
-                "\nFormat:\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:
-                await self._parse_and_execute_action(text)
-        except Exception as exc:
-            self._broadcast("error", f"File shared handler failed: {exc}", {"signalType": "file_shared", "error": str(exc)})
-
     # ================================================================
     #  Action request handling (proactive.action.request)
     # ================================================================
@@ -2892,105 +2506,6 @@ class AutonomousAgent:
                 )
                 result = msg_result if isinstance(msg_result, dict) else {"sent": True}
 
-            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_result = await self._runtime.memory._sign_and_relay(prep)
-                tx_hash = relay_result.get("txHash") if isinstance(relay_result, dict) else None
-                result = relay_result if isinstance(relay_result, dict) else {"txHash": str(relay_result)}
-
-            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_result = await self._runtime.memory._sign_and_relay(prep)
-                tx_hash = relay_result.get("txHash") if isinstance(relay_result, dict) else None
-                result = relay_result if isinstance(relay_result, dict) else {"txHash": str(relay_result)}
-
-            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_result = await self._runtime.memory._sign_and_relay(prep)
-                tx_hash = relay_result.get("txHash") if isinstance(relay_result, dict) else None
-                result = relay_result if isinstance(relay_result, dict) else {"txHash": str(relay_result)}
-
-            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_result = await self._runtime.memory._sign_and_relay(prep)
-                tx_hash = relay_result.get("txHash") if isinstance(relay_result, dict) else None
-                result = relay_result if isinstance(relay_result, dict) else {"txHash": str(relay_result)}
-
-            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_result = await self._runtime.memory._sign_and_relay(prep)
-                tx_hash = relay_result.get("txHash") if isinstance(relay_result, dict) else None
-                result = relay_result if isinstance(relay_result, dict) else {"txHash": str(relay_result)}
-
-            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", {}
-                )
-                if not isinstance(result, dict):
-                    result = {"accepted": True}
-
-            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", {}
-                )
-                if not isinstance(result, dict):
-                    result = {"declined": True}
-
-            elif action_type in ("grant", "grant_bounty_access"):
-                project_id = payload.get("projectId")
-                bounty_id = payload.get("bountyId")
-                request_id = payload.get("requestId")
-                if not project_id or not bounty_id or not request_id:
-                    raise ValueError("grant requires projectId, bountyId, requestId")
-                result = await self._runtime._http.request(
-                    "POST", f"/v1/projects/{project_id}/bounties/{bounty_id}/grant-access", {"requestId": request_id}
-                )
-                if not isinstance(result, dict):
-                    result = {"granted": True}
-
-            elif action_type in ("deny", "deny_bounty_access"):
-                project_id = payload.get("projectId")
-                bounty_id = payload.get("bountyId")
-                request_id = payload.get("requestId")
-                if not project_id or not bounty_id or not request_id:
-                    raise ValueError("deny requires projectId, bountyId, requestId")
-                result = await self._runtime._http.request(
-                    "POST", f"/v1/projects/{project_id}/bounties/{bounty_id}/deny-access", {"requestId": request_id}
-                )
-                if not isinstance(result, dict):
-                    result = {"denied": True}
-
             elif action_type == "workspace_create":
                 ws_name = payload.get("name") or suggested_content
                 if not ws_name:
@@ -3019,40 +2534,40 @@ class AutonomousAgent:
                 snap = await self._runtime.workspaces.create_snapshot(ws_id, label=payload.get("label"))
                 result = snap if isinstance(snap, dict) else {"created": True}
 
-            elif action_type in ("review", "comment"):
-                proj_id = payload.get("projectId")
-                commit_id = payload.get("commitId")
-                if not proj_id or not commit_id:
-                    raise ValueError("review requires projectId and commitId")
-                verdict = payload.get("verdict", "comment")
-                body = suggested_content or payload.get("body", "")
-                result = await self._runtime.projects.submit_review(proj_id, commit_id, verdict, body)
-                if not isinstance(result, dict):
-                    result = {"reviewed": True}
-
-            elif action_type == "accept":
-                ch = payload.get("channelId")
-                msg = suggested_content or "Accepted — I'll get started."
-                if ch:
-                    await self._runtime.channels.send(ch, msg)
-                result = {"accepted": True}
-
-            elif action_type == "acknowledge":
-                ch = payload.get("channelId")
-                msg = suggested_content or "Got it, thanks for the mention!"
-                if ch:
-                    await self._runtime.channels.send(ch, msg)
-                result = {"acknowledged": True}
-
-            elif action_type == "execute":
-                ch = payload.get("channelId")
-                target = payload.get("recipientAddress")
-                msg = suggested_content or ""
-                if ch:
-                    await self._runtime.channels.send(ch, msg)
-                elif target:
-                    await self._runtime.inbox.send(target, msg)
-                result = {"executed": True}
+            elif action_type == "propose_action":
+                ws_id = payload.get("workspaceId")
+                title = payload.get("title") or suggested_content
+                if not ws_id or not title:
+                    raise ValueError("propose_action requires workspaceId and title")
+                prop = await self._runtime.workspaces.create_proposal(
+                    ws_id,
+                    title=title,
+                    action_type=payload.get("actionType", "custom"),
+                    description=payload.get("description"),
+                    action_payload=payload.get("actionPayload"),
+                    quorum_type=payload.get("quorumType"),
+                    quorum_threshold=payload.get("quorumThreshold"),
+                )
+                result = prop if isinstance(prop, dict) else {"created": True}
+
+            elif action_type == "vote_proposal":
+                ws_id = payload.get("workspaceId")
+                proposal_id = payload.get("proposalId")
+                vote = payload.get("vote")
+                if not ws_id or not proposal_id or vote is None:
+                    raise ValueError("vote_proposal requires workspaceId, proposalId, vote")
+                vote_result = await self._runtime.workspaces.vote(
+                    ws_id, proposal_id, vote, reason=payload.get("reason"),
+                )
+                result = vote_result if isinstance(vote_result, dict) else {"voted": True}
+
+            elif action_type == "cancel_proposal":
+                ws_id = payload.get("workspaceId")
+                proposal_id = payload.get("proposalId")
+                if not ws_id or not proposal_id:
+                    raise ValueError("cancel_proposal requires workspaceId and proposalId")
+                cancel_result = await self._runtime.workspaces.cancel_proposal(ws_id, proposal_id)
+                result = cancel_result if isinstance(cancel_result, dict) else {"cancelled": True}
 
             elif action_type == "send_dm":
                 target = payload.get("recipientAddress")

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

@@ -3526,6 +3526,88 @@ class _WorkspaceManager:
         """Get activity log."""
         return await self._http.request("GET", f"/v1/workspaces/{workspace_id}/activity?limit={limit}&offset={offset}")
 
+    # ─── Proposals ───────────────────────────────────────────────
+
+    async def create_proposal(
+        self,
+        workspace_id: str,
+        title: str,
+        action_type: str = "custom",
+        description: str | None = None,
+        action_payload: dict[str, Any] | None = None,
+        quorum_type: str | None = None,
+        quorum_threshold: int | None = None,
+    ) -> dict[str, Any]:
+        """Create a proposal. Costs 0.25 credits."""
+        body: dict[str, Any] = {"title": title, "actionType": action_type}
+        if description is not None:
+            body["description"] = description
+        if action_payload is not None:
+            body["actionPayload"] = action_payload
+        if quorum_type is not None:
+            body["quorumType"] = quorum_type
+        if quorum_threshold is not None:
+            body["quorumThreshold"] = quorum_threshold
+        return await self._http.request("POST", f"/v1/workspaces/{workspace_id}/proposals", body)
+
+    async def list_proposals(
+        self,
+        workspace_id: str,
+        status: str | None = None,
+        limit: int = 50,
+        offset: int = 0,
+    ) -> dict[str, Any]:
+        """List proposals for a workspace."""
+        parts: list[str] = [f"limit={limit}", f"offset={offset}"]
+        if status:
+            parts.append(f"status={status}")
+        return await self._http.request("GET", f"/v1/workspaces/{workspace_id}/proposals?{'&'.join(parts)}")
+
+    async def get_proposal(self, workspace_id: str, proposal_id: str) -> dict[str, Any]:
+        """Get a specific proposal with votes."""
+        return await self._http.request("GET", f"/v1/workspaces/{workspace_id}/proposals/{proposal_id}")
+
+    async def vote(
+        self,
+        workspace_id: str,
+        proposal_id: str,
+        vote: bool,
+        reason: str | None = None,
+    ) -> dict[str, Any]:
+        """Vote on a proposal. Costs 0.05 credits."""
+        body: dict[str, Any] = {"vote": vote}
+        if reason is not None:
+            body["reason"] = reason
+        return await self._http.request("POST", f"/v1/workspaces/{workspace_id}/proposals/{proposal_id}/vote", body)
+
+    async def cancel_proposal(self, workspace_id: str, proposal_id: str) -> dict[str, Any]:
+        """Cancel a proposal. Proposer or admin+ only."""
+        return await self._http.request("DELETE", f"/v1/workspaces/{workspace_id}/proposals/{proposal_id}")
+
+    async def set_quorum_rule(
+        self,
+        workspace_id: str,
+        action_type: str,
+        quorum_type: str,
+        quorum_threshold: int | None = None,
+        min_voting_period_ms: int | None = None,
+    ) -> dict[str, Any]:
+        """Set a quorum rule for an action type. Admin+ only."""
+        body: dict[str, Any] = {"actionType": action_type, "quorumType": quorum_type}
+        if quorum_threshold is not None:
+            body["quorumThreshold"] = quorum_threshold
+        if min_voting_period_ms is not None:
+            body["minVotingPeriodMs"] = min_voting_period_ms
+        return await self._http.request("PUT", f"/v1/workspaces/{workspace_id}/quorum-rules", body)
+
+    async def get_quorum_rules(self, workspace_id: str) -> dict[str, Any]:
+        """Get quorum rules for a workspace."""
+        return await self._http.request("GET", f"/v1/workspaces/{workspace_id}/quorum-rules")
+
+    async def delete_quorum_rule(self, workspace_id: str, action_type: str) -> dict[str, Any]:
+        """Delete a quorum rule. Admin+ only."""
+        return await self._http.request("DELETE", f"/v1/workspaces/{workspace_id}/quorum-rules/{action_type}")
+
 
 # ============================================================
 #  Main Runtime Client

{nookplot_runtime-0.5.20 → nookplot_runtime-0.5.21}/nookplot_runtime/types.py

@@ -1018,11 +1018,15 @@ class BundleListResult(BaseModel):
 
 
 class CliqueMember(BaseModel):
-    """A member of a clique."""
+    """A member of a clique/guild.
+
+    Gateway returns enriched member objects: ``{address, status}``
+    where status is 0=None, 1=Invited, 2=Accepted, 3=Rejected, 4=Left.
+    """
 
     address: str
+    status: int = 0
     display_name: str | None = Field(None, alias="displayName")
-    approved: bool = False
 
     model_config = {"populate_by_name": True}
 

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

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