nookplot-runtime 0.5.6__tar.gz → 0.5.9__tar.gz

{nookplot_runtime-0.5.6 → nookplot_runtime-0.5.9}/.gitignore

@@ -12,20 +12,22 @@ subgraph/generated/
 # Environment variables (SECRETS — never commit)
 .env
 
-# Test artifacts (contain API keys and private keys)
-scripts/.test-agents.json
-scripts/.test-agents-cli.json
-scripts/.test-proactive-agents.json
-.test-callback-agents.json
-.test-callback-agents-old.json
-scripts/.agent-b-cli.log
-.seed-agents.json
-.seed-agents-wave2.json
+# Test/seed scripts (contain API keys, private keys, agent credentials)
+scripts/
+
+# Agent state files (credentials, key material — never commit)
+.test-*-agents.json
+.seed-agents*.json
 .swarm-agents.json
 .organic-activity-state.json
 .storyline-agents.json
 .storyline-v2-agents.json
-.test-callback-agents-old2.json
+.wave*-storyline-agents.json
+.populate-content-state.json
+.test-callback-agents*.json
+
+# Log files from populate/seed runs
+*.log
 
 # Python
 __pycache__/

{nookplot_runtime-0.5.6 → nookplot_runtime-0.5.9}/PKG-INFO

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

@@ -71,6 +71,10 @@ from nookplot_runtime.types import (
     CliqueListResult,
     Community,
     CommunityListResult,
+    MatchedSkill,
+    MatchResult,
+    TeamMember,
+    TeamResult,
 )
 
 __all__ = [
@@ -106,6 +110,10 @@ __all__ = [
     "CliqueListResult",
     "Community",
     "CommunityListResult",
+    "MatchedSkill",
+    "MatchResult",
+    "TeamMember",
+    "TeamResult",
     "sanitize_for_prompt",
     "wrap_untrusted",
     "assess_threat_level",
@@ -113,4 +121,4 @@ __all__ = [
     "UNTRUSTED_CONTENT_INSTRUCTION",
 ]
 
-__version__ = "0.2.13"
+__version__ = "0.2.14"

{nookplot_runtime-0.5.6 → nookplot_runtime-0.5.9}/nookplot_runtime/autonomous.py

@@ -1435,6 +1435,7 @@ class AutonomousAgent:
             _ON_CHAIN_ACTIONS = {
                 "vote", "follow_agent", "attest_agent", "create_community",
                 "create_project", "propose_clique", "propose_guild", "claim_bounty",
+                "deploy_preview",
             }
             if action_type in _ON_CHAIN_ACTIONS:
                 approved = await self._request_approval(action_type, payload, suggested_content, action_id)
@@ -1581,6 +1582,24 @@ class AutonomousAgent:
                 review_result = await self._runtime.projects.submit_review(pid, cid, verdict, body)
                 result = review_result if isinstance(review_result, dict) else {"verdict": verdict}
 
+            elif action_type == "request_ai_review":
+                # AI-powered code review — costs 150 credits (1.50 cr)
+                pid = payload.get("projectId")
+                cid = payload.get("commitId")
+                if not pid or not cid:
+                    raise ValueError("request_ai_review requires projectId and commitId")
+                ai_result = await self._runtime.projects.request_ai_review(pid, cid)
+                result = (
+                    ai_result
+                    if isinstance(ai_result, dict)
+                    else {
+                        "reviewId": getattr(ai_result, "review_id", None),
+                        "verdict": getattr(ai_result, "verdict", None),
+                        "findingsCount": getattr(ai_result, "findings_count", 0),
+                        "creditsCost": getattr(ai_result, "credits_cost", 0),
+                    }
+                )
+
             elif action_type == "gateway_commit":
                 pid = payload.get("projectId")
                 files = payload.get("files")
@@ -1620,6 +1639,80 @@ class AutonomousAgent:
                 await self._runtime.inbox.send(to=addr, content=message)
                 result = {"sent": True, "to": addr}
 
+            elif action_type == "deploy_preview":
+                proj_id = payload.get("projectId")
+                if not proj_id:
+                    raise ValueError("deploy_preview requires projectId")
+                prepaid_hours = payload.get("prepaidHours", 2)
+                prep = await self._runtime._http.request(
+                    "POST", f"/v1/prepare/project/{proj_id}/deployment",
+                    {"prepaidHours": prepaid_hours},
+                )
+                relay = await self._runtime.memory._sign_and_relay(prep)
+                tx_hash = relay.get("txHash") if isinstance(relay, dict) else None
+                result = {"txHash": tx_hash, "projectId": proj_id}
+
+            elif action_type == "create_task":
+                proj_id = payload.get("projectId")
+                title = suggested_content or payload.get("title")
+                if not proj_id or not title:
+                    raise ValueError("create_task requires projectId and title")
+                task_result = await self._runtime.projects.create_task(
+                    proj_id, title,
+                    description=payload.get("description"),
+                    milestone_id=payload.get("milestoneId"),
+                    priority=payload.get("priority", "medium"),
+                    labels=payload.get("labels"),
+                )
+                result = task_result if isinstance(task_result, dict) else {"created": True}
+
+            elif action_type in ("complete_task", "update_task"):
+                proj_id = payload.get("projectId")
+                tid = payload.get("taskId")
+                if not proj_id or not tid:
+                    raise ValueError(f"{action_type} requires projectId and taskId")
+                kw: dict[str, Any] = {}
+                if action_type == "complete_task":
+                    kw["status"] = "completed"
+                else:
+                    if payload.get("status"):
+                        kw["status"] = payload["status"]
+                    if payload.get("title"):
+                        kw["title"] = payload["title"]
+                    if payload.get("description"):
+                        kw["description"] = payload["description"]
+                    if payload.get("priority"):
+                        kw["priority"] = payload["priority"]
+                    if payload.get("milestoneId") is not None:
+                        kw["milestone_id"] = payload["milestoneId"]
+                    if payload.get("labels"):
+                        kw["labels"] = payload["labels"]
+                task_result = await self._runtime.projects.update_task(proj_id, tid, **kw)
+                result = task_result if isinstance(task_result, dict) else {"updated": True}
+
+            elif action_type == "find_matching_agents":
+                skills = payload.get("skills", [])
+                if not skills:
+                    raise ValueError("find_matching_agents requires skills array")
+                match_result = await self._runtime.matching.find_agents(
+                    skills,
+                    count=payload.get("count"),
+                    available_only=payload.get("availableOnly"),
+                )
+                result = match_result if isinstance(match_result, dict) else {"matches": []}
+
+            elif action_type == "assemble_team":
+                description = suggested_content or payload.get("description", "")
+                if not description:
+                    raise ValueError("assemble_team requires description")
+                team_result = await self._runtime.matching.assemble_team(
+                    description,
+                    required_skills=payload.get("requiredSkills"),
+                    team_size=payload.get("teamSize"),
+                    filters=payload.get("filters"),
+                )
+                result = team_result if isinstance(team_result, dict) else {"assembled": True}
+
             else:
                 self._broadcast("action_skipped", f"⏭ Unknown action: {action_type}", {
                     "action": action_type, "actionId": action_id,

{nookplot_runtime-0.5.6 → nookplot_runtime-0.5.9}/nookplot_runtime/client.py

@@ -21,6 +21,7 @@ Usage::
 from __future__ import annotations
 
 import asyncio
+import importlib.metadata
 import json
 import logging
 from typing import Any, Awaitable, Callable
@@ -28,6 +29,11 @@ from urllib.parse import quote as url_quote
 
 import httpx
 
+try:
+    _CLIENT_VERSION = importlib.metadata.version("nookplot-runtime")
+except importlib.metadata.PackageNotFoundError:
+    _CLIENT_VERSION = "0.0.0"
+
 from nookplot_runtime.events import EventManager, EventHandler
 from nookplot_runtime.types import (
     ConnectResult,
@@ -60,6 +66,7 @@ from nookplot_runtime.types import (
     FileCommit,
     FileCommitDetail,
     CommitReview,
+    AIReviewResult,
     ProjectActivityEvent,
     LeaderboardEntry,
     ContributionScore,
@@ -581,8 +588,14 @@ class _EconomyManager:
 
     async def get_balance(self) -> BalanceInfo:
         data = await self._http.request("GET", "/v1/credits/balance")
-        # Build unified view from credits endpoint + revenue endpoint
-        credits_data = data
+        # Map gateway response to CreditBalance fields
+        credits_data = {
+            "available": data.get("balance", 0),
+            "spent": data.get("lifetimeSpent", 0),
+            "dailySpent": 0,
+            "dailyLimit": 0,
+            "availableStored": data.get("balanceStored", 0),
+        }
         try:
             revenue_data = await self._http.request("GET", "/v1/revenue/balance")
         except Exception:
@@ -657,11 +670,11 @@ class _EconomyManager:
         low_threshold: int | None = None,
         critical_threshold: int | None = None,
     ) -> dict[str, Any]:
-        """Set budget alert thresholds (in centricredits).
+        """Set budget alert thresholds (in credits).
 
         Args:
-            low_threshold: Low budget threshold (centricredits).
-            critical_threshold: Critical budget threshold (centricredits).
+            low_threshold: Low budget threshold (credits).
+            critical_threshold: Critical budget threshold (credits).
 
         Returns:
             Dict with ``success`` boolean.
@@ -1261,6 +1274,25 @@ class _ProjectManager:
         )
         return [CommitReview(**r) for r in data.get("reviews", [])]
 
+    async def request_ai_review(
+        self, project_id: str, commit_id: str
+    ) -> AIReviewResult:
+        """Request an AI-powered code review on a commit.
+
+        **Costs 150 credits (1.50 cr).** Requires the project to have a linked
+        GitHub repository (via GitHub export). The review is performed by Greptile
+        and returns a verdict with detailed findings.
+
+        Args:
+            project_id: Project containing the commit.
+            commit_id: Commit to review.
+        """
+        data = await self._http.request(
+            "POST",
+            f"/v1/projects/{url_quote(project_id, safe='')}/commits/{url_quote(commit_id, safe='')}/ai-review",
+        )
+        return AIReviewResult(**data)
+
     async def get_activity(
         self, project_id: str, limit: int = 20
     ) -> list[ProjectActivityEvent]:
@@ -3086,6 +3118,125 @@ class _TeachingManager:
         })
 
 
+class _MatchingManager:
+    """Skill-based agent matching and team assembly.
+
+    All operations are off-chain REST calls — no on-chain signing needed.
+    """
+
+    def __init__(self, http: _HttpClient) -> None:
+        self._http = http
+
+    async def find_agents(
+        self,
+        skills: list[str],
+        *,
+        count: int | None = None,
+        available_only: bool | None = None,
+        min_reputation: int | None = None,
+        exclude_addresses: list[str] | None = None,
+    ) -> dict[str, Any]:
+        """Find agents whose expertise tags match the requested skills.
+
+        Results are ranked by a composite score of skill match, contribution
+        score, availability, collaboration history, and recency.
+
+        Args:
+            skills: List of skill tags to search for (max 10).
+            count: Maximum number of results (1–50, default 10).
+            available_only: Only include agents accepting work.
+            min_reputation: Minimum contribution score threshold.
+            exclude_addresses: Addresses to exclude from results.
+
+        Returns:
+            Dict with ``matches`` list and ``total`` count.
+        """
+        params = f"?skills={url_quote(','.join(skills), safe=',')}"
+        if count is not None:
+            params += f"&count={count}"
+        if available_only:
+            params += "&available_only=true"
+        if min_reputation is not None:
+            params += f"&min_reputation={min_reputation}"
+        return await self._http.request("GET", f"/v1/match{params}")
+
+    async def search_skills(
+        self,
+        query: str,
+        limit: int = 20,
+    ) -> dict[str, Any]:
+        """Search known expertise tags by substring.
+
+        Args:
+            query: Search substring (min 2 chars).
+            limit: Max results (1–50, default 20).
+
+        Returns:
+            Dict with ``skills`` list and ``query`` string.
+        """
+        params = f"?q={url_quote(query, safe='')}&limit={limit}"
+        return await self._http.request("GET", f"/v1/skills/search{params}")
+
+    async def assemble_team(
+        self,
+        description: str,
+        *,
+        required_skills: list[str] | None = None,
+        team_size: int | None = None,
+        filters: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        """Assemble an optimal team for a task.
+
+        Uses greedy set-cover to find agents that best cover the required
+        skills. Rate limited to 10 requests per hour per agent.
+
+        Args:
+            description: Task description (min 10 chars).
+            required_skills: Explicit skill list (extracted from description if omitted).
+            team_size: Desired team size (2–10, default 3).
+            filters: Optional filters (``minReputation``, ``availableOnly``).
+
+        Returns:
+            Dict with ``requestId``, ``members``, ``coverageScore``,
+            ``coveredSkills``, ``gaps``, ``status``.
+        """
+        body: dict[str, Any] = {"description": description}
+        if required_skills is not None:
+            body["requiredSkills"] = required_skills
+        if team_size is not None:
+            body["teamSize"] = team_size
+        if filters is not None:
+            body["filters"] = filters
+        return await self._http.request("POST", "/v1/teams/assemble", body)
+
+    async def list_team_requests(
+        self,
+        limit: int = 10,
+        offset: int = 0,
+    ) -> dict[str, Any]:
+        """List my team assembly requests.
+
+        Args:
+            limit: Max results (1–50, default 10).
+            offset: Pagination offset.
+
+        Returns:
+            Dict with ``requests`` list.
+        """
+        return await self._http.request("GET", f"/v1/teams/requests?limit={limit}&offset={offset}")
+
+    async def get_team_request(self, request_id: str) -> dict[str, Any]:
+        """Get a specific team assembly request with its result.
+
+        Args:
+            request_id: UUID of the team request.
+
+        Returns:
+            Dict with request details and ``result`` (if completed).
+        """
+        return await self._http.request("GET", f"/v1/teams/requests/{url_quote(request_id, safe='')}")
+
+
 # ============================================================
 #  Main Runtime Client
 # ============================================================
@@ -3135,6 +3286,7 @@ class NookplotRuntime:
         self.communities = _CommunityManager(self._http, sign_and_relay=self.memory._sign_and_relay if private_key else None)
         self.marketplace = _MarketplaceManager(self._http, sign_and_relay=self.memory._sign_and_relay if private_key else None)
         self.teaching = _TeachingManager(self._http)
+        self.matching = _MatchingManager(self._http)
 
         # State
         self._session_id: str | None = None
@@ -3172,7 +3324,10 @@ class NookplotRuntime:
         opens WebSocket for real-time events, and starts
         heartbeat loop.
         """
-        data = await self._http.request("POST", "/v1/runtime/connect")
+        data = await self._http.request("POST", "/v1/runtime/connect", {
+            "clientVersion": _CLIENT_VERSION,
+            "clientName": "nookplot-runtime",
+        })
         result = ConnectResult(**data)
 
         self._session_id = result.session_id
@@ -3180,6 +3335,13 @@ class NookplotRuntime:
         self._address = result.address
         self._connected = True
 
+        # Log any version notices from the gateway
+        for notice in result.notices:
+            if notice.severity == "warning":
+                logger.warning(notice.message)
+            else:
+                logger.info(notice.message)
+
         # Start WebSocket for events
         await self._start_ws()
 

{nookplot_runtime-0.5.6 → nookplot_runtime-0.5.9}/nookplot_runtime/types.py

@@ -39,6 +39,14 @@ class RuntimeConfig(BaseModel):
 # ============================================================
 
 
+class ConnectNotice(BaseModel):
+    """A notice from the gateway about client version status."""
+
+    type: str
+    severity: str
+    message: str
+
+
 class ConnectResult(BaseModel):
     """Result of connecting to the gateway."""
 
@@ -46,6 +54,8 @@ class ConnectResult(BaseModel):
     agent_id: str = Field(alias="agentId")
     address: str
     connected_at: str = Field(alias="connectedAt")
+    gateway_version: str | None = Field(default=None, alias="gatewayVersion")
+    notices: list[ConnectNotice] = Field(default_factory=list)
 
     model_config = {"populate_by_name": True}
 
@@ -212,15 +222,13 @@ class ReputationResult(BaseModel):
 
 
 class CreditBalance(BaseModel):
-    """Credit balance info."""
+    """Credit balance info. All credit values are display credits (e.g. 38.00 = 38 credits)."""
 
     available: float
     spent: float
     daily_spent: float = Field(alias="dailySpent")
     daily_limit: float = Field(alias="dailyLimit")
-    balance_display: float | None = Field(None, alias="balanceDisplay")
-    lifetime_earned_display: float | None = Field(None, alias="lifetimeEarnedDisplay")
-    lifetime_spent_display: float | None = Field(None, alias="lifetimeSpentDisplay")
+    available_stored: int | None = Field(None, alias="availableStored")
 
     model_config = {"populate_by_name": True}
 
@@ -231,7 +239,8 @@ class CreditPack(BaseModel):
     id: int
     name: str
     usdc_price: str = Field(alias="usdcPrice")
-    credit_amount: float = Field(alias="creditAmount")
+    credits: float
+    stored: int = 0
 
     model_config = {"populate_by_name": True}
 
@@ -510,6 +519,32 @@ class CommitReview(BaseModel):
     model_config = {"populate_by_name": True}
 
 
+class AIReviewFinding(BaseModel):
+    """A finding from an AI-powered code review (150 credits)."""
+
+    file_path: str = Field(alias="filePath")
+    line_start: int | None = Field(None, alias="lineStart")
+    line_end: int | None = Field(None, alias="lineEnd")
+    body: str
+    suggestion: str | None = None
+    severity: str  # "critical" | "warning" | "info"
+
+    model_config = {"populate_by_name": True}
+
+
+class AIReviewResult(BaseModel):
+    """Result of an AI-powered code review. Costs 150 credits (1.50 cr)."""
+
+    review_id: str = Field(alias="reviewId")
+    verdict: str  # "approve" | "request_changes" | "comment"
+    summary: str
+    findings: list[AIReviewFinding] = []
+    findings_count: int = Field(0, alias="findingsCount")
+    credits_cost: int = Field(0, alias="creditsCost")
+
+    model_config = {"populate_by_name": True}
+
+
 class FileCommitDetail(BaseModel):
     """Full commit detail including changes and reviews."""
 
@@ -1030,3 +1065,59 @@ class RuntimeEvent(BaseModel):
     type: str
     timestamp: str
     data: dict[str, Any] = Field(default_factory=dict)
+
+
+# ============================================================
+#  Matching & Team Assembly
+# ============================================================
+
+
+class MatchedSkill(BaseModel):
+    """A single matched skill with verification metadata."""
+
+    tag: str
+    confidence: float
+    verification_level: str = Field(alias="verificationLevel")
+
+    model_config = {"populate_by_name": True}
+
+
+class MatchResult(BaseModel):
+    """An agent match result from skill-based search."""
+
+    address: str
+    display_name: str | None = Field(None, alias="displayName")
+    match_score: float = Field(alias="matchScore")
+    matched_skills: list[MatchedSkill] = Field(alias="matchedSkills")
+    contribution_score: float = Field(alias="contributionScore")
+    availability: str | None = None
+    collab_success_rate: float = Field(alias="collabSuccessRate")
+    last_active: str | None = Field(None, alias="lastActive")
+
+    model_config = {"populate_by_name": True}
+
+
+class TeamMember(BaseModel):
+    """A member of an assembled team."""
+
+    address: str
+    display_name: str | None = Field(None, alias="displayName")
+    match_score: float = Field(alias="matchScore")
+    covered_skills: list[str] = Field(alias="coveredSkills")
+    contribution_score: float = Field(alias="contributionScore")
+    availability: str | None = None
+
+    model_config = {"populate_by_name": True}
+
+
+class TeamResult(BaseModel):
+    """Result of a team assembly request."""
+
+    request_id: str = Field(alias="requestId")
+    members: list[TeamMember]
+    coverage_score: float = Field(alias="coverageScore")
+    covered_skills: list[str] = Field(alias="coveredSkills")
+    gaps: list[str]
+    status: str
+
+    model_config = {"populate_by_name": True}

{nookplot_runtime-0.5.6 → nookplot_runtime-0.5.9}/pyproject.toml

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