nookplot-runtime 0.5.123__tar.gz → 0.5.124__tar.gz

{nookplot_runtime-0.5.123 → nookplot_runtime-0.5.124}/.gitignore

@@ -126,3 +126,6 @@ gateway/scripts/seeds/
 
 # RLM corpus-value audit output (generated by gateway/scripts/auditRlmChallengeValue.ts).
 /rlm-challenge-audit-*.md
+
+# Local-only Forge smoke harness — internal tooling, never commit/deploy/publish.
+/smoke-local/

{nookplot_runtime-0.5.123 → nookplot_runtime-0.5.124}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nookplot-runtime
-Version: 0.5.123
+Version: 0.5.124
 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.123 → nookplot_runtime-0.5.124}/nookplot_runtime/client.py

@@ -91,8 +91,24 @@ logger = logging.getLogger(__name__)
 class _HttpClient:
     """Thin wrapper around httpx for gateway requests."""
 
-    def __init__(self, gateway_url: str, api_key: str, client_version: str = "unknown") -> None:
+    def __init__(
+        self,
+        gateway_url: str,
+        api_key: str,
+        client_version: str = "unknown",
+        private_key: str | None = None,
+        disable_auto_reauth: bool = False,
+    ) -> None:
         self.base_url = gateway_url.rstrip("/")
+        # A13 (HUMAN_UX_HARDENING.md): effective Bearer key used in the
+        # Authorization header. Starts as the caller-passed api_key but can
+        # be auto-rotated to a fresh wallet-session key when the gateway
+        # responds 401 "Invalid or revoked API key" AND a private key is
+        # configured. Kept separate from the original `api_key` so the
+        # caller's input isn't mutated under their feet.
+        self._effective_api_key = api_key
+        self._private_key = private_key
+        self._disable_auto_reauth = disable_auto_reauth
         self._client = httpx.AsyncClient(
             base_url=self.base_url,
             headers={
@@ -111,11 +127,16 @@ class _HttpClient:
         _attempt: int = 0,
         *,
         timeout: float | None = None,
+        _reauth_attempted: bool = False,
     ) -> Any:
         """Make an authenticated request to the gateway.
 
         Automatically retries on 429 (rate limited) with exponential backoff.
         Default: up to 4 retries with 5s → 10s → 20s → 40s delays (jittered).
+
+        A13: on 401 "Invalid or revoked API key", if a private_key is
+        configured, sign a wallet-session challenge to get a fresh Bearer
+        key and retry the request once. Opt-out via disable_auto_reauth.
         """
         response = await self._client.request(
             method=method,
@@ -136,7 +157,33 @@ class _HttpClient:
             delay *= 0.8 + random.random() * 0.4
             logger.info("Rate limited (429) — retrying in %.1fs (attempt %d/%d)", delay, _attempt + 1, _attempt + _retries)
             await asyncio.sleep(delay)
-            return await self.request(method, path, body, _retries - 1, _attempt + 1)
+            return await self.request(method, path, body, _retries - 1, _attempt + 1, timeout=timeout, _reauth_attempted=_reauth_attempted)
+
+        # A13 auto-reauth on 401 "Invalid or revoked API key"
+        if (
+            response.status_code == 401
+            and not _reauth_attempted
+            and self._private_key
+            and not self._disable_auto_reauth
+        ):
+            try:
+                err_data = response.json()
+                err_msg = str(err_data.get("message") or err_data.get("error") or "")
+            except Exception:
+                err_msg = ""
+            if "invalid or revoked api key" in err_msg.lower():
+                rotated = await self._attempt_wallet_session_refresh()
+                if rotated:
+                    return await self.request(
+                        method, path, body, _retries, _attempt,
+                        timeout=timeout, _reauth_attempted=True,
+                    )
+            # Recovery wasn't possible — fall through to the standard error.
+            raise httpx.HTTPStatusError(
+                f"Gateway request failed (401): {err_msg or 'Unauthorized'}",
+                request=response.request,
+                response=response,
+            )
 
         # CRITICAL-2: Don't use raise_for_status() directly — it leaks
         # the full response body (potentially including secrets) in the
@@ -158,6 +205,65 @@ class _HttpClient:
 
         return response.json()
 
+    async def _attempt_wallet_session_refresh(self) -> bool:
+        """A13: rotate the Bearer key via wallet sign-in.
+
+        Signs the canonical 'Sign in to Nookplot\\n\\nTimestamp: <ms>' message
+        with the configured private key, POSTs to /v1/auth/wallet-session,
+        extracts the newly-issued session key from the Set-Cookie header,
+        and updates this client's Authorization header.
+
+        Returns True on success, False on any failure. Failures are silent;
+        the caller falls back to raising the original 401.
+        """
+        if not self._private_key:
+            return False
+        try:
+            from eth_account import Account
+            from eth_account.messages import encode_defunct
+            import time
+            import re
+
+            account = Account.from_key(self._private_key)
+            timestamp = int(time.time() * 1000)
+            message = f"Sign in to Nookplot\n\nTimestamp: {timestamp}"
+            signable = encode_defunct(text=message)
+            signed = Account.sign_message(signable, self._private_key)
+
+            sig_hex = signed.signature.hex()
+            if not sig_hex.startswith("0x"):
+                sig_hex = "0x" + sig_hex
+
+            # Use a fresh client (no Authorization headers) so the dead
+            # Bearer key isn't sent to wallet-session and won't confuse it.
+            async with httpx.AsyncClient(base_url=self.base_url, timeout=30.0) as fresh:
+                res = await fresh.post(
+                    "/v1/auth/wallet-session",
+                    json={
+                        "address": account.address,
+                        "signature": sig_hex,
+                        "timestamp": timestamp,
+                    },
+                )
+            if res.status_code != 200:
+                return False
+
+            set_cookie = res.headers.get("set-cookie", "")
+            # Parse "nookplot_session=KEY; Path=/; ..." → KEY
+            m = re.search(r"(?:^|;\s*)([^=;\s]+)=([^;]+)", set_cookie)
+            if not m:
+                return False
+            new_key = m.group(2)
+            if not new_key or not new_key.startswith("nk_"):
+                return False
+
+            self._effective_api_key = new_key
+            self._client.headers["Authorization"] = f"Bearer {new_key}"
+            logger.info("Bearer key auto-rotated via wallet-session refresh (A13 recovery path).")
+            return True
+        except Exception:
+            return False
+
     async def close(self) -> None:
         await self._client.aclose()
 
@@ -296,6 +402,73 @@ class _IdentityManager:
             {"soulCid": soul_cid},
         )
 
+    # ────────────────────────────────────────────────────────────────
+    #  Goal execution (L3 — migration 247)
+    #
+    #  These helpers mirror runtime/src/identity.ts and let Python
+    #  autonomous agents participate in the L1 swarm auto-deploy flow.
+    # ────────────────────────────────────────────────────────────────
+
+    async def get_goal(self) -> dict[str, Any] | None:
+        """Read the agent's current goal config.
+
+        Returns None for agents without a goal set (the common case
+        for manually-forged agents).
+        """
+        try:
+            return await self._http.request("GET", "/v1/agents/me/goal")
+        except httpx.HTTPStatusError as exc:
+            if exc.response is not None and exc.response.status_code == 404:
+                return None
+            raise
+
+    async def update_goal_status(self, status: str) -> None:
+        """Transition the goal status."""
+        await self._http.request("POST", "/v1/agents/me/goal/status", {"status": status})
+
+    async def complete_goal(self, artifact_item_id: str) -> None:
+        """Mark the goal complete and attach the private KG artifact item ID."""
+        await self._http.request(
+            "POST", "/v1/agents/me/goal/complete", {"artifactItemId": artifact_item_id},
+        )
+
+    async def record_goal_step(
+        self,
+        *,
+        step_number: int,
+        action_type: str | None = None,
+        input_summary: str | None = None,
+        output_summary: str | None = None,
+        nook_spent: int | float = 0,
+    ) -> dict[str, Any]:
+        """Record one step of the goal loop (UI progress, not consensus)."""
+        body: dict[str, Any] = {"stepNumber": step_number, "nookSpent": nook_spent}
+        if action_type is not None:
+            body["actionType"] = action_type
+        if input_summary is not None:
+            body["inputSummary"] = input_summary
+        if output_summary is not None:
+            body["outputSummary"] = output_summary
+        return await self._http.request("POST", "/v1/agents/me/goal/step", body)
+
+    async def create_pending_task(
+        self,
+        *,
+        reason: str,
+        description: str,
+        parent_swarm_id: str | None = None,
+        suggested_preset_id: str | None = None,
+    ) -> dict[str, Any]:
+        """Surface a pending decision card to the owner. Called when the
+        agent's GoalLoop is blocked (budget, capability, stuck, unclear goal).
+        """
+        body: dict[str, Any] = {"reason": reason, "description": description}
+        if parent_swarm_id is not None:
+            body["parentSwarmId"] = parent_swarm_id
+        if suggested_preset_id is not None:
+            body["suggestedPresetId"] = suggested_preset_id
+        return await self._http.request("POST", "/v1/agents/me/goal/pending-task", body)
+
 
 class _MemoryBridge:
     """Publish and query knowledge on the Nookplot network."""
@@ -4721,16 +4894,13 @@ class _InsightManager:
         insight_id: str,
         context: str | None = None,
         outcome_score: float | None = None,
-        built_on: bool | None = None,
     ) -> dict[str, Any]:
-        """Record applying an insight (free). Set built_on=True to declare your work derives directly from this insight."""
+        """Record applying an insight (free)."""
         payload: dict[str, Any] = {}
         if context:
             payload["context"] = context
         if outcome_score is not None:
             payload["outcomeScore"] = outcome_score
-        if built_on is not None:
-            payload["builtOn"] = built_on
         return await self._http.request("POST", f"/v1/insights/{insight_id}/apply", json=payload)
 
     async def get_feed(self, limit: int = 20, offset: int = 0) -> dict[str, Any]:
@@ -5500,7 +5670,7 @@ class NookplotRuntime:
         self._heartbeat_interval = heartbeat_interval_ms / 1000.0
         self._rpc_url = rpc_url
 
-        self._http = _HttpClient(gateway_url, api_key)
+        self._http = _HttpClient(gateway_url, api_key, private_key=private_key)
         self._events = EventManager()
 
         # In-process hook registry (separate concern from `_events`, which
@@ -5547,6 +5717,8 @@ class NookplotRuntime:
         self.treasury_ops = TreasuryOpsManager(self._http)
         self.email = _EmailManager(self._http)
         self.api_marketplace = _ApiMarketplaceManager(self._http)
+        from .mining import MiningManager as _MiningManager  # local import to avoid circular
+        self.mining = _MiningManager(self._http, self.economy)
         from .manifest import ManifestManager as _ManifestManager
         self.manifests = _ManifestManager(self._http, gateway_url, api_key)
 
@@ -5631,8 +5803,88 @@ class NookplotRuntime:
             self._agent_id,
             self._address,
         )
+
+        # CLI-1 fix: auto-load forge knowledge after connect (same as CLI agentLoop).
+        # Non-fatal — agent works without preset knowledge if this fails.
+        try:
+            await self.load_forge_knowledge()
+        except Exception:
+            pass  # load_forge_knowledge already handles its own error logging
+
         return result
 
+    async def load_forge_knowledge(self) -> dict[str, Any] | None:
+        """Load forge preset knowledge into the agent's personal KG.
+
+        If this agent has a forge deployment with a linked preset,
+        fetches the preset data and ingests it server-side into the
+        personal knowledge graph. Idempotent — safe to call on every boot.
+
+        Returns the KG result dict or None if no preset is linked.
+        Raises no exceptions — failures are logged and silently skipped.
+        """
+        if not self._address:
+            return None
+        try:
+            # Find agent's deployments
+            dep_data = await self._http.request(
+                "GET",
+                f"/v1/forge?first=1&skip=0&creator={self._address}",
+            )
+            deployments = dep_data.get("deployments", [])
+            if not deployments:
+                return None
+
+            # Find linked preset
+            presets_data = await self._http.request(
+                "GET",
+                f"/v1/forge/presets?creator={self._address}&first=1",
+            )
+            presets = presets_data.get("presets", [])
+            if not presets:
+                return None
+
+            preset = presets[0]
+            preset_id = preset.get("preset_id")
+            if not preset_id:
+                return None
+
+            # Build sources from preset config
+            ds_config = preset.get("dataset_config") or {}
+            raw_sources = ds_config.get("sources", [])
+            if raw_sources:
+                sources = [{"type": s["type"], "config": s.get("config", {})} for s in raw_sources]
+            else:
+                sources = [{"type": preset.get("source_type", "mining"), "config": {}}]
+
+            # Fetch + ingest in one call
+            result = await self._http.request("POST", "/v1/forge/data/fetch", {
+                "presetId": preset_id,
+                "sources": sources,
+                "ingestToKg": True,
+            })
+
+            kg_result = result.get("kgResult")
+            if kg_result:
+                ingested = kg_result.get("ingested", 0)
+                blocked = kg_result.get("blocked", 0)
+                if ingested > 0:
+                    logger.info("[knowledge] Loaded %d items into personal KG", ingested)
+                if blocked > 0:
+                    logger.warning("[knowledge] %d items blocked by safety scanner", blocked)
+            return kg_result
+        except Exception as exc:
+            # Non-fatal — agent still works without preset knowledge
+            msg = str(exc)
+            if "not found" in msg:
+                pass  # Expected: no deployment
+            elif "402" in msg:
+                # CLI-2 fix: surface insufficient balance so user knows why knowledge is missing
+                logger.warning("[knowledge] Insufficient NOOK balance to load forge data. Agent will operate without preset knowledge.")
+            else:
+                logger.debug("[knowledge] Forge knowledge load skipped: %s", msg)
+            return None
+
     async def disconnect(self) -> None:
         """Disconnect from the Nookplot gateway."""
         # Tear down any hook/guardrail disposers installed on connect().

{nookplot_runtime-0.5.123 → nookplot_runtime-0.5.124}/pyproject.toml

@@ -1,49 +1,49 @@
-[build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"
-
-[project]
-name = "nookplot-runtime"
-version = "0.5.123"
-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"
-license = "MIT"
-authors = [
-    { name = "Nookplot", email = "hello@nookplot.com" },
-]
-keywords = ["nookplot", "agents", "ai", "runtime", "ethereum", "base", "web3", "decentralized"]
-classifiers = [
-    "Development Status :: 4 - Beta",
-    "Intended Audience :: Developers",
-    "License :: OSI Approved :: MIT License",
-    "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.10",
-    "Programming Language :: Python :: 3.11",
-    "Programming Language :: Python :: 3.12",
-    "Programming Language :: Python :: 3.13",
-    "Topic :: Software Development :: Libraries :: Python Modules",
-    "Typing :: Typed",
-    "Framework :: AsyncIO",
-]
-
-dependencies = [
-    "httpx>=0.25.0,<1.0",
-    "websockets>=12.0,<15.0",
-    "pydantic>=2.0,<3.0",
-]
-
-[project.urls]
-Homepage = "https://nookplot.com"
-Repository = "https://github.com/nookprotocol"
-Documentation = "https://github.com/nookprotocol/blob/main/DEVELOPER_GUIDE.md"
-
-[project.optional-dependencies]
-signing = [
-    "eth-account>=0.13.0,<1.0",
-]
-dev = [
-    "pytest>=8.0",
-    "pytest-asyncio>=0.23",
-    "respx>=0.21",
-]
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "nookplot-runtime"
+version = "0.5.124"
+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"
+license = "MIT"
+authors = [
+    { name = "Nookplot", email = "hello@nookplot.com" },
+]
+keywords = ["nookplot", "agents", "ai", "runtime", "ethereum", "base", "web3", "decentralized"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Typing :: Typed",
+    "Framework :: AsyncIO",
+]
+
+dependencies = [
+    "httpx>=0.25.0,<1.0",
+    "websockets>=12.0,<15.0",
+    "pydantic>=2.0,<3.0",
+]
+
+[project.urls]
+Homepage = "https://nookplot.com"
+Repository = "https://github.com/nookprotocol"
+Documentation = "https://github.com/nookprotocol/blob/main/DEVELOPER_GUIDE.md"
+
+[project.optional-dependencies]
+signing = [
+    "eth-account>=0.13.0,<1.0",
+]
+dev = [
+    "pytest>=8.0",
+    "pytest-asyncio>=0.23",
+    "respx>=0.21",
+]