nookplot-runtime 0.5.13__tar.gz → 0.5.15__tar.gz

{nookplot_runtime-0.5.13 → nookplot_runtime-0.5.15}/.gitignore

@@ -26,6 +26,7 @@ scripts/
 .storyline-v2-agents.json
 .populate-content-state.json
 .biomimicry-activity-state.json
+.cypher-swarm.json
 
 # Log files from populate/seed runs
 *.log

{nookplot_runtime-0.5.13 → nookplot_runtime-0.5.15}/PKG-INFO

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

@@ -244,6 +244,45 @@ class AutonomousAgent:
             return f"team_inv:{data.get('invitationId', '')}"
         if signal_type in ("team_invitation_accepted", "team_invitation_declined"):
             return f"team_resp:{data.get('invitationId', '')}"
+        # Bounty application/submission signals
+        if signal_type == "bounty_application_submitted":
+            return f"bounty_app:{data.get('applicationId', '')}"
+        if signal_type == "bounty_application_approved":
+            return f"bounty_app_approve:{data.get('applicationId', '')}"
+        if signal_type == "bounty_application_rejected":
+            return f"bounty_app_reject:{data.get('applicationId', '')}"
+        if signal_type == "bounty_work_submitted":
+            return f"bounty_work:{data.get('submissionId', '')}"
+        if signal_type == "bounty_submission_selected":
+            return f"bounty_sel:{data.get('submissionId', '')}"
+        if signal_type == "bounty_submission_not_selected":
+            return f"bounty_notsel:{data.get('bountyId', '')}:{addr}"
+        # On-chain bounty lifecycle signals
+        if signal_type == "bounty_claimed":
+            return f"bounty_claimed:{data.get('bountyId', '')}"
+        if signal_type == "bounty_work_approved":
+            return f"bounty_work_approved:{data.get('bountyId', '')}"
+        if signal_type == "bounty_disputed":
+            return f"bounty_disputed:{data.get('bountyId', '')}:{addr}"
+        if signal_type == "bounty_cancelled":
+            return f"bounty_cancelled:{data.get('bountyId', '')}"
+        if signal_type == "bounty_claimer_approved":
+            return f"bounty_claimer_approved:{data.get('bountyId', '')}:{addr}"
+        # Marketplace signals
+        if signal_type == "agreement_created":
+            return f"agreement_created:{data.get('agreementId', '')}"
+        if signal_type == "work_delivered":
+            return f"work_delivered:{data.get('agreementId', '')}"
+        if signal_type == "agreement_settled":
+            return f"agreement_settled:{data.get('agreementId', '')}"
+        if signal_type == "agreement_disputed":
+            return f"agreement_disputed:{data.get('agreementId', '')}"
+        if signal_type == "agreement_cancelled":
+            return f"agreement_cancelled:{data.get('agreementId', '')}"
+        if signal_type == "revision_requested":
+            return f"revision_requested:{data.get('agreementId', '')}"
+        if signal_type == "review_received":
+            return f"review_received:{data.get('agreementId', '')}"
         return f"{signal_type}:{addr}:{data.get('channelId', '')}:{data.get('postCid', '')}"
 
     async def _handle_signal(self, data: dict[str, Any]) -> None:
@@ -342,6 +381,61 @@ class AutonomousAgent:
             self._broadcast("action_skipped", f"📋 Team invitation {signal_type}: {data.get('inviteeAddress', '?')}", {
                 "signalType": signal_type, "invitationId": data.get("invitationId"),
             })
+        # ── Bounty application/submission signals ──
+        elif signal_type == "bounty_application_submitted":
+            await self._handle_bounty_application_submitted(data)
+        elif signal_type == "bounty_application_approved":
+            await self._handle_bounty_application_approved(data)
+        elif signal_type == "bounty_application_rejected":
+            self._broadcast("action_skipped", f"Bounty application rejected for bounty #{data.get('bountyId', '?')}", {
+                "signalType": signal_type, "bountyId": data.get("bountyId"),
+            })
+        elif signal_type == "bounty_work_submitted":
+            await self._handle_bounty_work_submitted(data)
+        elif signal_type == "bounty_submission_selected":
+            await self._handle_bounty_submission_selected(data)
+        elif signal_type == "bounty_submission_not_selected":
+            self._broadcast("action_skipped", f"Bounty submission not selected for bounty #{data.get('bountyId', '?')}", {
+                "signalType": signal_type, "bountyId": data.get("bountyId"),
+            })
+        # ── On-chain bounty lifecycle signals ──
+        elif signal_type == "bounty_claimed":
+            self._broadcast("action_skipped", f"Bounty #{data.get('bountyId', '?')} claimed by {data.get('claimerAddress', '?')}", {
+                "signalType": signal_type, "bountyId": data.get("bountyId"),
+            })
+        elif signal_type == "bounty_work_approved":
+            self._broadcast("action_skipped", f"Bounty #{data.get('bountyId', '?')} work approved — reward released", {
+                "signalType": signal_type, "bountyId": data.get("bountyId"),
+            })
+        elif signal_type == "bounty_disputed":
+            self._broadcast("action_skipped", f"Bounty #{data.get('bountyId', '?')} work disputed", {
+                "signalType": signal_type, "bountyId": data.get("bountyId"),
+            })
+        elif signal_type == "bounty_cancelled":
+            self._broadcast("action_skipped", f"Bounty #{data.get('bountyId', '?')} cancelled by creator", {
+                "signalType": signal_type, "bountyId": data.get("bountyId"),
+            })
+        elif signal_type == "bounty_claimer_approved":
+            await self._handle_bounty_claimer_approved(data)
+        # ── Marketplace signals ──
+        elif signal_type == "agreement_created":
+            await self._handle_agreement_created(data)
+        elif signal_type == "work_delivered":
+            await self._handle_work_delivered(data)
+        elif signal_type == "agreement_settled":
+            await self._handle_agreement_settled(data)
+        elif signal_type == "agreement_disputed":
+            await self._handle_agreement_disputed(data)
+        elif signal_type == "agreement_cancelled":
+            self._broadcast("action_skipped", f"Agreement #{data.get('agreementId', '?')} cancelled", {
+                "signalType": signal_type, "agreementId": data.get("agreementId"),
+            })
+        elif signal_type == "revision_requested":
+            await self._handle_revision_requested(data)
+        elif signal_type == "review_received":
+            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"),
+            })
         else:
             self._broadcast("action_skipped", f"⏭ Unhandled signal type: {signal_type}", {
                 "signalType": signal_type,
@@ -831,6 +925,323 @@ class AutonomousAgent:
                 "action": "team_invitation", "invitationId": invitation_id, "error": str(exc),
             })
 
+    # ── Marketplace signal handlers ──
+
+    async def _parse_and_execute_action(self, text: str) -> None:
+        """Parse an LLM response in 'ACTION: <type>\\nPARAMS: <json>' format and dispatch."""
+        import re, json as _json
+        action_match = re.search(r"ACTION:\s*(\S+)", text, re.IGNORECASE)
+        if not action_match:
+            if self._verbose:
+                logger.debug("[autonomous] No action parsed from response")
+            return
+        action_type = action_match.group(1).lower()
+
+        payload: dict[str, Any] = {}
+        params_match = re.search(r"PARAMS:\s*(\{[\s\S]*\})", text, re.IGNORECASE)
+        if params_match:
+            try:
+                payload = _json.loads(params_match.group(1))
+            except _json.JSONDecodeError:
+                if self._verbose:
+                    logger.debug("[autonomous] Failed to parse PARAMS JSON")
+
+        await self._handle_action_request({
+            "actionType": action_type,
+            "payload": payload,
+        })
+
+    async def _handle_agreement_created(self, data: dict[str, Any]) -> None:
+        """Provider received a new agreement — decide whether to start work."""
+        agreement_id = data.get("agreementId", "")
+        buyer_address = data.get("buyerAddress", "")
+        escrow_amount = data.get("escrowAmount", "0")
+        description = data.get("description", "")
+
+        try:
+            prompt = (
+                "You've been hired for a service agreement on Nookplot.\n"
+                f"Agreement #{agreement_id}\n"
+                f"Buyer: {str(buyer_address)[:12]}...\n"
+                f"Escrow: {escrow_amount} (locked until you deliver)\n"
+                + (f"Terms: {str(description)[:500]}\n" if description else "")
+                + "\nReview the terms and decide your next step.\n\n"
+                "Available actions:\n"
+                "- deliver_work: Submit your completed work (params: agreementId, deliveryCid)\n"
+                "- send_agreement_message: Send a message to the buyer (params: agreementId, messageType='general', content)\n"
+                "\nFormat:\nACTION: <action_type>\nPARAMS: <json params>\n"
+                "Or respond with ACKNOWLEDGE if you need more time."
+            )
+
+            assert self._generate_response is not None
+            response = await self._generate_response(prompt)
+            text = (response or "").strip()
+
+            if "ACKNOWLEDGE" in text.upper() or not text:
+                self._broadcast("action_executed", f"Acknowledged Agreement #{agreement_id}", {
+                    "action": "agreement_acknowledged", "agreementId": agreement_id,
+                })
+                return
+
+            await self._parse_and_execute_action(text)
+        except Exception as exc:
+            self._broadcast("error", f"Agreement created handling failed: {exc}", {
+                "action": "agreement_created", "agreementId": agreement_id, "error": str(exc),
+            })
+
+    async def _handle_work_delivered(self, data: dict[str, Any]) -> None:
+        """Buyer receives delivery — decide whether to settle, dispute, or request revision."""
+        agreement_id = data.get("agreementId", "")
+        escrow_amount = data.get("escrowAmount", "0")
+
+        try:
+            prompt = (
+                "Work has been delivered for a service agreement on Nookplot.\n"
+                f"Agreement #{agreement_id}\n"
+                f"Escrow: {escrow_amount}\n"
+                "\nYou are the buyer. Review the submission and decide:\n\n"
+                "Available actions:\n"
+                "- settle_agreement: Approve work and release escrow (params: agreementId)\n"
+                "- dispute_agreement: Dispute the delivery (params: agreementId)\n"
+                "- send_agreement_message: Request revision (params: agreementId, messageType='revision_request', content)\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"Work delivered handling failed: {exc}", {
+                "action": "work_delivered", "agreementId": agreement_id, "error": str(exc),
+            })
+
+    async def _handle_agreement_settled(self, data: dict[str, Any]) -> None:
+        """Provider receives settlement — optionally submit a review."""
+        agreement_id = data.get("agreementId", "")
+        escrow_amount = data.get("escrowAmount", "0")
+
+        try:
+            prompt = (
+                "A service agreement has been settled on Nookplot — escrow released to you.\n"
+                f"Agreement #{agreement_id}\n"
+                f"Amount received: {escrow_amount}\n\n"
+                "Would you like to submit a review for the buyer?\n\n"
+                "Available actions:\n"
+                '- submit_review: Leave a review (params: agreementId, rating (1-5), comment)\n'
+                "\nFormat:\nACTION: submit_review\n"
+                'PARAMS: {"agreementId": ..., "rating": ..., "comment": "..."}\n'
+                "Or respond with SKIP to not leave a review."
+            )
+
+            assert self._generate_response is not None
+            response = await self._generate_response(prompt)
+            text = (response or "").strip()
+
+            if "SKIP" in text.upper() or not text:
+                self._broadcast("action_executed", f"Agreement #{agreement_id} settled (no review)", {
+                    "action": "agreement_settled_noted", "agreementId": agreement_id,
+                })
+                return
+
+            await self._parse_and_execute_action(text)
+        except Exception as exc:
+            self._broadcast("error", f"Agreement settled handling failed: {exc}", {
+                "action": "agreement_settled", "agreementId": agreement_id, "error": str(exc),
+            })
+
+    async def _handle_agreement_disputed(self, data: dict[str, Any]) -> None:
+        """Agent receives dispute notification — submit evidence."""
+        agreement_id = data.get("agreementId", "")
+
+        try:
+            prompt = (
+                "A service agreement has been disputed on Nookplot.\n"
+                f"Agreement #{agreement_id}\n\n"
+                "You should provide evidence to support your position.\n\n"
+                "Available actions:\n"
+                "- send_agreement_message: Submit evidence (params: agreementId, messageType='dispute_evidence', content)\n"
+                "\nFormat:\nACTION: send_agreement_message\n"
+                'PARAMS: {"agreementId": ..., "messageType": "dispute_evidence", "content": "..."}'
+            )
+
+            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"Agreement disputed handling failed: {exc}", {
+                "action": "agreement_disputed", "agreementId": agreement_id, "error": str(exc),
+            })
+
+    async def _handle_revision_requested(self, data: dict[str, Any]) -> None:
+        """Provider receives revision request — revise and re-deliver."""
+        agreement_id = data.get("agreementId", "")
+        message = data.get("message", "")
+
+        try:
+            prompt = (
+                "The buyer has requested a revision on your delivered work.\n"
+                f"Agreement #{agreement_id}\n"
+                + (f"Revision request: {str(message)[:500]}\n" if message else "")
+                + "\nRevise your work and re-deliver, or send a response.\n\n"
+                "Available actions:\n"
+                "- deliver_work: Submit revised work (params: agreementId, deliveryCid)\n"
+                "- send_agreement_message: Respond to the buyer (params: agreementId, messageType='revision_response', content)\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"Revision requested handling failed: {exc}", {
+                "action": "revision_requested", "agreementId": agreement_id, "error": str(exc),
+            })
+
+    # ── Bounty application/submission signal handlers ──
+
+    async def _handle_bounty_application_submitted(self, data: dict[str, Any]) -> None:
+        """Bounty creator receives an application — approve or reject."""
+        bounty_id = data.get("bountyId", "")
+        application_id = data.get("applicationId", "")
+        applicant = data.get("senderAddress", "?")
+        preview = data.get("messagePreview", "")
+
+        try:
+            prompt = (
+                "An agent has applied to work on your bounty.\n"
+                f"Bounty #{bounty_id}\n"
+                f"Applicant: {str(applicant)[:12]}...\n"
+                + (f"Application message: {str(preview)[:200]}\n" if preview else "")
+                + f"Application ID: {application_id}\n\n"
+                "Review the application and decide whether to approve or reject.\n\n"
+                "Available actions:\n"
+                "- approve_bounty_application: Approve the applicant (params: bountyId, applicationId)\n"
+                "- reject_bounty_application: Reject the applicant (params: bountyId, applicationId)\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"Bounty application handling failed: {exc}", {
+                "action": "bounty_application_submitted", "bountyId": bounty_id, "error": str(exc),
+            })
+
+    async def _handle_bounty_application_approved(self, data: dict[str, Any]) -> None:
+        """Applicant receives approval — submit work."""
+        bounty_id = data.get("bountyId", "")
+
+        try:
+            prompt = (
+                "Your bounty application has been approved!\n"
+                f"Bounty #{bounty_id}\n\n"
+                "You can now submit your work for this bounty.\n\n"
+                "Available actions:\n"
+                "- submit_bounty_work: Submit your work (params: bountyId, content)\n"
+                "- ignore: Take no action yet\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 application approved handling failed: {exc}", {
+                "action": "bounty_application_approved", "bountyId": bounty_id, "error": str(exc),
+            })
+
+    async def _handle_bounty_work_submitted(self, data: dict[str, Any]) -> None:
+        """Bounty creator receives work submission — review and select."""
+        bounty_id = data.get("bountyId", "")
+        submission_id = data.get("submissionId", "")
+        submitter = data.get("senderAddress", "?")
+        preview = data.get("messagePreview", "")
+
+        try:
+            prompt = (
+                "An applicant has submitted work for your bounty.\n"
+                f"Bounty #{bounty_id}\n"
+                f"Submitter: {str(submitter)[:12]}...\n"
+                f"Submission ID: {submission_id}\n"
+                + (f"Work preview: {str(preview)[:200]}\n" if preview else "")
+                + "\nReview the submission and decide whether to select it as the winner.\n\n"
+                "Available actions:\n"
+                "- select_bounty_submission: Select this submission as the winner (params: bountyId, submissionId)\n"
+                "- ignore: Take no action yet (wait for more submissions)\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 work submitted handling failed: {exc}", {
+                "action": "bounty_work_submitted", "bountyId": bounty_id, "error": str(exc),
+            })
+
+    async def _handle_bounty_submission_selected(self, data: dict[str, Any]) -> None:
+        """Winner receives selection — claim bounty on-chain."""
+        bounty_id = data.get("bountyId", "")
+
+        try:
+            prompt = (
+                "Your submission was selected as the winner!\n"
+                f"Bounty #{bounty_id}\n\n"
+                "You can now claim the bounty reward on-chain.\n\n"
+                "Available actions:\n"
+                "- claim_bounty: Claim the bounty reward on-chain (params: bountyId)\n"
+                "- ignore: Take no action yet\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 submission selected handling failed: {exc}", {
+                "action": "bounty_submission_selected", "bountyId": bounty_id, "error": str(exc),
+            })
+
+    async def _handle_bounty_claimer_approved(self, data: dict[str, Any]) -> None:
+        """Approved claimer receives notification — claim the bounty."""
+        bounty_id = data.get("bountyId", "")
+        reward_amount = data.get("rewardAmount", "0")
+
+        try:
+            prompt = (
+                "You've been approved to claim a bounty on-chain!\n"
+                f"Bounty #{bounty_id}, Reward: {reward_amount}\n\n"
+                "You can now claim the bounty reward.\n\n"
+                "Available actions:\n"
+                "- claim_bounty: Claim the bounty reward on-chain (params: bountyId)\n"
+                "- ignore: Take no action yet\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 claimer approved handling failed: {exc}", {
+                "action": "bounty_claimer_approved", "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."""
         topic = data.get("messagePreview", "")
@@ -1526,7 +1937,7 @@ class AutonomousAgent:
             _ON_CHAIN_ACTIONS = {
                 "vote", "follow_agent", "attest_agent", "create_community",
                 "create_project", "propose_clique", "propose_guild", "claim_bounty",
-                "create_bounty", "deploy_preview", "create_bundle",
+                "create_bounty", "approve_bounty_claimer", "deploy_preview", "create_bundle",
                 "link_project_to_guild", "link_project_to_clique",
                 "list_service", "create_agreement", "deliver_work",
                 "settle_agreement", "dispute_agreement", "cancel_agreement",
@@ -1703,19 +2114,86 @@ class AutonomousAgent:
                 commit_result = await self._runtime.projects.commit_files(pid, files, msg)
                 result = commit_result if isinstance(commit_result, dict) else {"committed": True}
 
-            elif action_type == "claim_bounty":
+            elif action_type == "apply_bounty":
+                bounty_id = payload.get("bountyId")
+                if not bounty_id:
+                    raise ValueError("apply_bounty requires bountyId")
+                apply_msg = suggested_content or payload.get("message", "")
+                apply_result = await self._runtime._http.request(
+                    "POST", f"/v1/bounties/{bounty_id}/apply", {"message": apply_msg}
+                )
+                result = apply_result if isinstance(apply_result, dict) else {"applied": True}
+
+            elif action_type == "submit_bounty_work":
+                bounty_id = payload.get("bountyId")
+                if not bounty_id:
+                    raise ValueError("submit_bounty_work requires bountyId")
+                work_content = suggested_content or payload.get("content", "")
+                if not work_content:
+                    raise ValueError("submit_bounty_work requires content")
+                cids = payload.get("deliverableCids", [])
+                sub_result = await self._runtime._http.request(
+                    "POST", f"/v1/bounties/{bounty_id}/submissions",
+                    {"content": work_content, "deliverableCids": cids}
+                )
+                result = sub_result if isinstance(sub_result, dict) else {"submitted": True}
+
+            elif action_type in ("claim", "claim_bounty"):
                 bounty_id = payload.get("bountyId")
-                submission = suggested_content or payload.get("submission", "")
                 if not bounty_id:
                     raise ValueError("claim_bounty requires bountyId")
-                # Use prepare+relay flow (POST /v1/bounties/:id/claim returns 410 Gone)
+                # Only works if agent is the selected winner (application flow gate)
                 prep = await self._runtime._http.request(
-                    "POST", f"/v1/prepare/bounty/{bounty_id}/claim", {"submission": submission}
+                    "POST", f"/v1/prepare/bounty/{bounty_id}/claim", {}
                 )
                 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 == "approve_bounty_claimer":
+                bounty_id = payload.get("bountyId")
+                claimer = payload.get("claimer")
+                if not bounty_id:
+                    raise ValueError("approve_bounty_claimer requires bountyId")
+                if not claimer:
+                    raise ValueError("approve_bounty_claimer requires claimer")
+                prep = await self._runtime._http.request(
+                    "POST", f"/v1/prepare/bounty/{bounty_id}/approve-claimer", {"claimer": claimer}
+                )
+                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 {"approved": True}
+
+            elif action_type == "approve_bounty_application":
+                bounty_id = payload.get("bountyId")
+                application_id = payload.get("applicationId")
+                if not bounty_id or not application_id:
+                    raise ValueError("approve_bounty_application requires bountyId and applicationId")
+                result_raw = await self._runtime._http.request(
+                    "POST", f"/v1/bounties/{bounty_id}/applications/{application_id}/approve", {}
+                )
+                result = result_raw if isinstance(result_raw, dict) else {"approved": True}
+
+            elif action_type == "reject_bounty_application":
+                bounty_id = payload.get("bountyId")
+                application_id = payload.get("applicationId")
+                if not bounty_id or not application_id:
+                    raise ValueError("reject_bounty_application requires bountyId and applicationId")
+                result_raw = await self._runtime._http.request(
+                    "POST", f"/v1/bounties/{bounty_id}/applications/{application_id}/reject", {}
+                )
+                result = result_raw if isinstance(result_raw, dict) else {"rejected": True}
+
+            elif action_type == "select_bounty_submission":
+                bounty_id = payload.get("bountyId")
+                submission_id = payload.get("submissionId")
+                if not bounty_id or not submission_id:
+                    raise ValueError("select_bounty_submission requires bountyId and submissionId")
+                result_raw = await self._runtime._http.request(
+                    "POST", f"/v1/bounties/{bounty_id}/submissions/{submission_id}/select", {}
+                )
+                result = result_raw if isinstance(result_raw, dict) else {"selected": True}
+
             elif action_type == "create_bounty":
                 title = suggested_content or payload.get("title")
                 desc = payload.get("description", "")

{nookplot_runtime-0.5.13 → nookplot_runtime-0.5.15}/pyproject.toml

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