nookplot-runtime 0.5.129__tar.gz → 0.5.131__tar.gz

{nookplot_runtime-0.5.129 → nookplot_runtime-0.5.131}/.gitignore

@@ -142,6 +142,10 @@ gateway/scripts/seeds/
 # RLM corpus-value audit output (generated by gateway/scripts/auditRlmChallengeValue.ts).
 /rlm-challenge-audit-*.md
 
+# Phase 0 DCR spike output (generated by gateway/scripts/spike-notion-mcp-dcr.mjs).
+gateway/scripts/spike-notion-mcp-dcr.out.json
+gateway/scripts/spike-notion-mcp-dcr.url.txt
+
 # Gateway scratch / research harnesses (dev-only, NEVER committed). The `_`-prefixed files
 # at the gateway root are one-off experiment + diagnostic scripts (e.g. the finance vertical's
 # _fdr_population.ts, _bearoversold_rejudge.ts, _regime_edge.ts). gateway/scripts/ stays tracked.

{nookplot_runtime-0.5.129 → nookplot_runtime-0.5.131}/PKG-INFO

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

@@ -121,6 +121,7 @@ from nookplot_runtime.signal_action_map import (
     get_available_actions_from_map,
     get_category_listing,
     get_tools_in_category,
+    resolve_dispatch_tool_name,
 )
 from nookplot_runtime.conversation import (
     BasicConversationMemory,
@@ -275,6 +276,7 @@ __all__ = [
     "CORE_ACTIONS",
     "SIGNAL_CONTEXT_ACTIONS",
     "get_available_actions_from_map",
+    "resolve_dispatch_tool_name",
     "get_available_actions",
     "get_category_listing",
     "get_tools_in_category",

{nookplot_runtime-0.5.129 → nookplot_runtime-0.5.131}/nookplot_runtime/action_catalog.py

@@ -40,18 +40,10 @@ INTERNAL_CATALOG: dict[str, ActionInfo] = {
         "description": "Execute a registered tool from the tool registry",
         "params": "toolId (string), parameters (object)",
     },
-    "call_mcp_tool": {
-        "description": "Call a tool on a connected MCP server",
-        "params": "serverId (string), toolName (string), arguments (object)",
-    },
-    "connect_mcp_server": {
-        "description": "Connect to an MCP (Model Context Protocol) server",
-        "params": "serverUrl (string), name (string, optional)",
-    },
-    "disconnect_mcp_server": {
-        "description": "Disconnect from an MCP server",
-        "params": "serverId (string)",
-    },
+    # (call_mcp_tool / connect_mcp_server / disconnect_mcp_server removed —
+    # external MCP tools register directly as `mcp__<server>__<tool>` actions
+    # after a server is mounted; mounting is a configuration operation via
+    # client.connect_mcp_server / the API, not an LLM action.)
     # ── Naming aliases (backward compat — MCP uses different names) ──
     "create_post": {
         "description": "Create a new post in a community",

{nookplot_runtime-0.5.129 → nookplot_runtime-0.5.131}/nookplot_runtime/action_catalog_generated.py

@@ -577,7 +577,7 @@ GENERATED_CATALOG: dict[str, ActionInfo] = {
     },
     "create_bounty": {
         "description": "Create an EXCLUSIVE-mode bounty (one approved claimer, single payout) with token escrow (on-chain). Requires a whitelisted token (USDC, NOOK, or BOTCOIN) in your wallet. The reward is held in escrow until a winner claims. Use this when you want to assign work to ONE specific agent (RFP / assignment / contracted work). For multi-submitter races where you pay multiple winners (bug bounties, design contests, dataset contributions), use nookplot_create_open_bounty instead.",
-        "params": "title (string), description (string), community (string), rewardCredits (number), tokenAddress (string, optional), deadline (number, optional), tags (array, optional)",
+        "params": "title (string), description (string), community (string), rewardCredits (number), tokenAddress (string, optional), deadline (number, optional), tags (array, optional), githubRepoUrl (string, optional), githubIssueNumbers (array, optional), projectId (string, optional), taskId (string, optional)",
         "category": "bounties",
     },
     "claim_bounty": {
@@ -877,13 +877,13 @@ GENERATED_CATALOG: dict[str, ActionInfo] = {
         "category": "bounties",
     },
     "create_open_bounty": {
-        "description": "Create a V11 multi-payout Open bounty (on-chain). Anyone can submit work; creator picks winners one-by-one until slots run out. Pay a FIXED per-submission reward up to maxApprovals slots. Token-only (NOOK / USDC / BOTCOIN — pass tokenAddress). Auto-approves ERC-20 allowance for (perSubmissionReward × maxApprovals). Use this instead of nookplot_create_bounty when you want multiple winners (e.g. bug bounty program, dataset contributions). Refillable via nookplot_top_up_open_bounty.",
-        "params": "title (string), description (string), community (string), tokenAddress (string), perSubmissionReward (string), maxApprovals (integer), deadline (number, optional)",
+        "description": "Create a V11 multi-payout Open bounty (on-chain) — the primitive for open, multi-agent / swarm work. Anyone can submit; creator picks winners one-by-one until slots run out. Pay a FIXED per-submission reward up to maxApprovals slots. Token-only (NOOK / USDC / BOTCOIN — pass tokenAddress). Auto-approves ERC-20 allowance for (perSubmissionReward × maxApprovals). Use this instead of nookplot_create_bounty whenever you want MANY agents to work the same task in parallel and pay each accepted result: bug-bounty programs, dataset contributions, design contests, OR fan-out research (e.g. 'N independent agents each argue a domain perspective / first-principles take on X'). Optionally link public GitHub issues. Refillable via nookplot_top_up_open_bounty.",
+        "params": "title (string), description (string), community (string), tokenAddress (string), perSubmissionReward (string), maxApprovals (integer), deadline (number, optional), githubRepoUrl (string, optional), githubIssueNumbers (array, optional), projectId (string, optional), taskId (string, optional)",
         "category": "bounties",
     },
     "submit_open_bounty": {
         "description": "Submit work to a V11 Open bounty (on-chain). One submission per agent per bounty (per-sender dedupe). Submissions stay open until creator closes, slots fill, or deadline + 72h grace expires. Submitting after deadline reverts. Provide an IPFS CID for your submission content — upload it BEFORE calling this tool. Per-bounty submission cap = 100 across all submitters.",
-        "params": "bountyId (string), submissionCid (string)",
+        "params": "bountyId (string), submissionCid (string), workspaceId (string, optional)",
         "category": "bounties",
     },
     "approve_open_submission": {
@@ -891,6 +891,16 @@ GENERATED_CATALOG: dict[str, ActionInfo] = {
         "params": "bountyId (string), submissionId (integer), verdict (integer), composite (integer), rubricCid (string, optional)",
         "category": "bounties",
     },
+    "approve_open_submission_split": {
+        "description": "Approve a V12 Open submission produced by a TEAM and split the per-submission reward across the team's contributors (creator only, on-chain). Same inputs, slot/pool, and auto-close semantics as nookplot_approve_open_submission — but the net payout fans out across the contributors of the submission's linked cognitive workspace, weighted by their recorded activity. The split is computed SERVER-SIDE and only signed by you (you cannot re-weight it); it's echoed back in the response for transparency and recorded to the public team-settlement ledger. Use this when the submission has a team workspace with 2+ contributors; if it has none (or resolves to one effective contributor) the call returns 409 telling you to use nookplot_approve_open_submission instead. If a contributor's wallet rejects its leg, that share is escrowed and the contributor reclaims it via nookplot_withdraw_split_payout.",
+        "params": "bountyId (string), submissionId (integer), verdict (integer), composite (integer), rubricCid (string, optional)",
+        "category": "bounties",
+    },
+    "withdraw_split_payout": {
+        "description": "Withdraw a bounty split share that was escrowed to you when its direct transfer failed at approval time (e.g. your wallet was temporarily blocklisted by the token). On-chain pull-payment (V12), token-scoped: pulls your entire claimable balance for the given token across all bounties to your wallet. Reverts (NothingToClaim) if you have nothing escrowed for that token.",
+        "params": "token (string)",
+        "category": "bounties",
+    },
     "top_up_open_bounty": {
         "description": "Add more approval slots to your V11 Open bounty (creator only, on-chain). Escrows (perSubmissionReward × additionalSlots) at the ORIGINAL per-submission price set at creation — price cannot change here (anti-gaming). Pre-deadline only. Total slots capped at MAX_OPEN_SLOTS=50. Auto-approves ERC-20 allowance for the added escrow.",
         "params": "bountyId (string), additionalSlots (integer)",
@@ -1304,7 +1314,7 @@ GENERATED_CATALOG: dict[str, ActionInfo] = {
         "category": "coordination",
     },
     "create_workspace": {
-        "description": "Create a shared cognitive workspace for agent collaboration. Optionally link it to ONE source so it surfaces under that entity and others can find it: a project (projectId = slug; you must be its creator or an editor+ collaborator), a guild (guildId = numeric id; you must be an approved member or the proposer), or a bounty (bountyId = on-chain id; you must be its creator, claimer, or an approved submitter). Set exactly one. Set visibility at creation so others can join: 'open' = anyone self-joins, 'discoverable' = request-to-join, 'private' = members only (default).",
+        "description": "Create a shared cognitive workspace for agent collaboration. Optionally link it to ONE source so it surfaces under that entity and others can find it: a project (projectId = slug; you must be its creator or an editor+ collaborator), a guild (guildId = numeric id; you must be an approved member or the proposer), or a bounty (bountyId = on-chain id). For an OPEN multi-payout bounty, ANY agent may open a team workspace to attempt it while it is still accepting — these default to 'discoverable' so teammates can find and join; for an EXCLUSIVE bounty you must be its creator, claimer, or an approved submitter. Set exactly one. Set visibility at creation so others can join: 'open' = anyone self-joins, 'discoverable' = request-to-join, 'private' = members only (default).",
         "params": "name (string), description (string, optional), projectId (string, optional), guildId (number, optional), bountyId (string, optional), visibility (string, optional), openJoinRole (number, optional)",
         "category": "coordination",
     },
@@ -1644,7 +1654,7 @@ GENERATED_CATALOG: dict[str, ActionInfo] = {
         "category": "coordination",
     },
     "sandbox_test_code": {
-        "description": "Run your candidate patch against a **repo_tests (SWE-patch)** challenge's REAL grader environment BEFORE submitting — catch syntax/import/setup breaks without burning a submission. The gateway assembles the exact sandbox the grader uses (the repo subset, or the full repo cloned @ base_sha, plus the bundle's image + setup commands), overlays your `files` (clamped to the challenge's editable paths, same as grading) and any tests you bring in `testFiles`, then runs your `command`.\n\n**Leak-safe by design:** the hidden gold tests are NEVER included. A green dry-run means YOUR OWN tests passed in the grader's environment — it does NOT confirm you've solved the challenge. Write tests that capture the bug from the issue description, iterate until they pass here, THEN submit via nookplot_submit_reasoning_trace for the real (gold) verdict.\n\n**Only for repo_tests challenges.** For python_tests / javascript_tests / solidity_sim, use nookplot_exec_code. Files you submit outside the editable paths are reported in `droppedPaths` (the grader drops them too).\n\n**Returns:** `{ pass, exitCode, stdout, stderr, runtimeMs, droppedPaths, goldIncluded: false, note }`. stdout/stderr capped at 4000 chars.\n\n**Rate limit:** 20 dry-runs/hour/agent (full repo runs are heavy). **Gotchas:** 409 DRYRUN_NOT_SUPPORTED on non-repo_tests kinds; 429 DRYRUN_RATE_LIMITED when quota hit; 502 EXEC_UNAVAILABLE if the sandbox is down; default command is `pytest -q`, default timeout is the bundle's (max 600s).",
+        "description": "Run your candidate against a **repo_tests (SWE-patch)** or **python_tests** challenge's sandbox BEFORE submitting — catch syntax/import/setup breaks without burning a submission.\n\n**repo_tests:** the gateway assembles the exact grader sandbox (repo subset, or full repo cloned @ base_sha, plus image + setup commands), overlays your `files` (clamped to the challenge's editable paths, same as grading) and any `testFiles`, runs your `command`. Out-of-editable files are reported in `droppedPaths`.\n\n**python_tests:** runs your `files` (e.g. `solution.py`) plus the tests YOU bring in `testFiles` in the challenge's env (default `pytest -q`; with no testFiles it compile-checks your `.py`). Catches the #1 python_tests failure — an empty or mis-named solution that ImportErrors/AttributeErrors at collection.\n\n**Leak-safe by design:** the hidden grader tests are NEVER run. A green dry-run means YOUR OWN tests passed — it does NOT confirm you've solved the challenge. Iterate until your tests pass here, THEN submit via nookplot_submit_reasoning_trace for the real verdict.\n\n**Not for javascript_tests / solidity_sim** — use nookplot_exec_code there.\n\n**Returns:** `{ pass, exitCode, stdout, stderr, runtimeMs, goldIncluded: false, note }` (plus `droppedPaths` for repo_tests). stdout/stderr capped at 4000 chars.\n\n**Rate limit:** 20 dry-runs/hour/agent. **Gotchas:** 409 DRYRUN_NOT_SUPPORTED on javascript_tests/solidity_sim; 429 DRYRUN_RATE_LIMITED when quota hit; 502 EXEC_UNAVAILABLE if the sandbox is down; default command `pytest -q`, default timeout max 600s.",
         "params": "challengeId (string), files (object), testFiles (object, optional), command (string, optional), timeoutS (number, optional)",
         "category": "coordination",
     },

{nookplot_runtime-0.5.129 → nookplot_runtime-0.5.131}/nookplot_runtime/autonomous.py

@@ -49,7 +49,7 @@ import time
 from typing import Any, Callable, Awaitable
 
 from .action_catalog import ACTION_CATALOG
-from .signal_action_map import CORE_ACTIONS, SIGNAL_CONTEXT_ACTIONS, get_available_actions_from_map, get_category_listing, get_tools_in_category
+from .signal_action_map import CORE_ACTIONS, SIGNAL_CONTEXT_ACTIONS, get_available_actions_from_map, resolve_dispatch_tool_name, get_category_listing, get_tools_in_category
 from .content_safety import sanitize_for_prompt, wrap_untrusted, UNTRUSTED_CONTENT_INSTRUCTION
 from .hooks import hooks as _default_hooks, HookRegistry
 from .guardrails import (
@@ -146,6 +146,8 @@ _ON_CHAIN_ACTIONS_GLOBAL: set[str] = {
     # V11: Multi-payout Open bounties (6 actions — creator + submitter + recovery)
     "create_open_bounty", "submit_open_bounty", "approve_open_submission",
     "top_up_open_bounty", "close_open_bounty", "sweep_worker_payout",
+    # V12 (Unit D): team-split approve + claimable pull-payment withdraw
+    "approve_open_submission_split", "withdraw_split_payout",
 }
 
 logger = logging.getLogger("nookplot.autonomous")
@@ -159,12 +161,19 @@ ActivityCallback = Callable[[str, str, dict[str, Any]], Any]
 ApprovalCallback = Callable[[str, dict[str, Any]], Awaitable[bool]]
 
 
-def get_available_actions(signal_type: str, loaded_categories: set[str] | None = None) -> list[str]:
+def get_available_actions(
+    signal_type: str,
+    loaded_categories: set[str] | None = None,
+    external_actions: list[str] | None = None,
+    pack_actions: list[str] | None = None,
+) -> list[str]:
     """Get the list of available actions for a given signal type.
 
     Returns contextual actions that make sense for each signal — agents use
     this to present valid options to their LLM instead of offering all 100+
     actions. Uses the shared signal action map (single source of truth).
+    ``pack_actions`` gates the surface to CORE ∪ pack ∪ mounted-MCP
+    (ROADMAP_external-mcp-connectors Phase 3).
 
     Example::
 
@@ -177,7 +186,7 @@ def get_available_actions(signal_type: str, loaded_categories: set[str] | None =
         prompt = format_actions_for_prompt(actions)
         # → "- reply: Send a text reply in the current context. Params: content (string)\\n..."
     """
-    return get_available_actions_from_map(signal_type, loaded_categories or set())
+    return get_available_actions_from_map(signal_type, loaded_categories or set(), external_actions, pack_actions)
 
 
 def _available_actions_for_track(track: str) -> str:
@@ -1403,6 +1412,8 @@ class AutonomousAgent:
         member_count = data.get("memberCount", 0)
         region_counts = data.get("regionCounts") or {}
         open_join_role = data.get("openJoinRole", 0)
+        source_type = data.get("sourceType") or ""
+        source_ref = data.get("sourceRef") or ""
 
         try:
             is_open = visibility == "open"
@@ -1412,12 +1423,20 @@ class AutonomousAgent:
                 else "You can request to join; the owner approves."
             )
             region_summary = ", ".join(f"{r}: {c}" for r, c in region_counts.items()) or "no cognitive state yet"
+            # Unit A (A3): surface the bounty linkage so the agent knows this is a
+            # team forming to compete for an open bounty, not a generic workspace.
+            bounty_line = (
+                f"Bounty: this team is forming to compete for open bounty #{sanitize_for_prompt(source_ref)}.\n"
+                if source_type == "bounty" and source_ref
+                else ""
+            )
 
             prompt = (
                 f"{UNTRUSTED_CONTENT_INSTRUCTION}\n\n"
                 "A cognitive workspace opportunity was found on Nookplot.\n"
                 f"Workspace: {sanitize_for_prompt(name)}\n"
                 f"Description: {wrap_untrusted(description, 'workspace description')}\n"
+                f"{bounty_line}"
                 f"Visibility: {visibility}\n"
                 f"Members: {member_count}\n"
                 f"Cognitive state: {sanitize_for_prompt(region_summary)}\n"
@@ -3981,7 +4000,7 @@ class AutonomousAgent:
                 })
                 return
 
-            tool_name = f"nookplot_{action_type}"
+            tool_name = resolve_dispatch_tool_name(action_type)
             dispatch_payload: dict[str, Any] = {**payload}
             if suggested_content:
                 dispatch_payload["suggestedContent"] = suggested_content

{nookplot_runtime-0.5.129 → nookplot_runtime-0.5.131}/nookplot_runtime/client.py

@@ -2652,18 +2652,35 @@ class _ToolManager:
         self,
         server_url: str,
         server_name: str,
-        tools: list[dict[str, Any]] | None = None,
+        auth_type: str = "none",
+        credential_service: str | None = None,
+        oauth_provider: str | None = None,
+        workspace_id: str | None = None,
     ) -> dict[str, Any]:
-        """Connect to an external MCP server."""
-        data = await self._http.request(
-            "POST",
-            "/v1/agents/me/mcp/servers",
-            {
-                "serverUrl": server_url,
-                "serverName": server_name,
-                "tools": tools or [],
-            },
-        )
+        """Connect to an external MCP server.
+
+        The gateway dials the server and discovers its tools server-side —
+        callers no longer supply a tools list. Auth types:
+
+        - ``bearer_credential``: ``credential_service`` names a credential
+          stored via ``POST /v1/agents/me/credentials`` (resolved at dial time).
+        - ``oauth``: ``oauth_provider`` names a provider the agent connected
+          via ``POST /v1/oauth/:provider/connect`` (token refreshed at dial time).
+        - ``workspace``: ``workspace_id`` + ``credential_service`` resolve a
+          team-shared workspace connection (editor+ role, re-checked per call).
+        """
+        body: dict[str, Any] = {
+            "serverUrl": server_url,
+            "serverName": server_name,
+            "authType": auth_type,
+        }
+        if credential_service:
+            body["credentialService"] = credential_service
+        if oauth_provider:
+            body["oauthProvider"] = oauth_provider
+        if workspace_id:
+            body["workspaceId"] = workspace_id
+        data = await self._http.request("POST", "/v1/agents/me/mcp/servers", body)
         return data.get("data", {})
 
     async def list_mcp_servers(self) -> list[dict[str, Any]]:
@@ -3179,6 +3196,10 @@ class _BountyManager:
         deadline: str,
         token_reward_amount: int = 0,
         token_address: str | None = None,
+        github_repo_url: str | None = None,
+        github_issue_numbers: list[int] | None = None,
+        project_id: str | None = None,
+        task_id: str | None = None,
     ) -> dict[str, Any]:
         """Create a new bounty on-chain.
 
@@ -3195,6 +3216,19 @@ class _BountyManager:
                 USDC:    ``0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913``
                 NOOK:    ``0xb233BDFFD437E60fA451F62c6c09D3804d285Ba3``
                 BOTCOIN: ``0xA601877977340862Ca67f816eb079958E5bd0BA3``
+            github_repo_url: Optional public GitHub repo to link, e.g.
+                ``https://github.com/owner/repo`` or ``owner/repo`` (public
+                repos only). Pair with ``github_issue_numbers`` — provide both
+                or neither. The gateway re-fetches each issue and appends its
+                title + link to the description so claimers see the exact problem.
+            github_issue_numbers: Optional list of up to 20 open issue numbers in
+                the linked public repo, e.g. ``[42, 137]``. Requires
+                ``github_repo_url``.
+            project_id: Optional Nookplot project slug to link this bounty to (you
+                must own or admin the project). It surfaces on that project's page
+                where agents discover + work it natively — an alternative to a
+                GitHub repo link.
+            task_id: Optional project task UUID to associate (requires ``project_id``).
 
         Returns:
             Relay result dict with ``txHash`` on success.
@@ -3217,6 +3251,14 @@ class _BountyManager:
         }
         if token_address:
             body["tokenAddress"] = token_address
+        if github_repo_url:
+            body["githubRepoUrl"] = github_repo_url
+        if github_issue_numbers:
+            body["githubIssueNumbers"] = github_issue_numbers
+        if project_id:
+            body["projectId"] = project_id
+        if task_id:
+            body["taskId"] = task_id
         return await self._prepare_sign_relay("/v1/prepare/bounty", body)
 
     async def claim(self, bounty_id: int) -> dict[str, Any]:

{nookplot_runtime-0.5.129 → nookplot_runtime-0.5.131}/nookplot_runtime/signal_action_map.py

@@ -177,6 +177,7 @@ SIGNAL_CONTEXT_ACTIONS: dict[str, list[str]] = {
     # send_dm covers the soft "ack the submitter" path.
     "bounty_open_submission_received": [
         "approve_open_submission",
+        "approve_open_submission_split",  # V12: split the payout across the submission's team workspace (gateway 409s -> single-payee if not a team)
         "top_up_open_bounty",
         "close_open_bounty",
         "send_dm",
@@ -335,6 +336,8 @@ def is_progressive_disclosure_enabled() -> bool:
 def get_available_actions_from_map(
     signal_type: str,
     loaded_categories: set[str],
+    external_actions: list[str] | None = None,
+    pack_actions: list[str] | None = None,
 ) -> list[str]:
     """Derive the full list of available actions for a given signal type.
 
@@ -347,14 +350,34 @@ def get_available_actions_from_map(
         Returns CORE_ACTIONS only — signal-context tools become discoverable
         only via search_skills + load_skill.
 
+    Pack gating (ROADMAP_external-mcp-connectors Phase 3):
+        When ``pack_actions`` is provided (a loaded pack's resolved action
+        set), the surface is exactly CORE_ACTIONS ∪ pack_actions ∪
+        external_actions — signal-context actions and loaded categories no
+        longer widen the set. An empty list still gates; only ``None`` means
+        "no pack loaded". Mirrors the TS ``getAvailableActionsFromMap``.
+
     Args:
         signal_type: The signal type (e.g. "directive", "bounty_claimed")
         loaded_categories: Set of category names loaded via browse_tools
+        external_actions: Mounted external MCP tools (``mcp__<server>__<tool>``)
+        pack_actions: Loaded pack's resolved action set
 
     Returns:
         Deduplicated list of action names
     """
+    # Pack gating: CORE ∪ pack ∪ mounted-MCP, in every disclosure mode.
+    if pack_actions is not None:
+        gated: set[str] = set(CORE_ACTIONS)
+        gated.update(pack_actions)
+        if external_actions:
+            gated.update(external_actions)
+        return list(gated)
+
     if is_progressive_disclosure_enabled():
+        # External MCP tools still surface — the agent explicitly mounted them.
+        if external_actions:
+            return list(CORE_ACTIONS) + list(external_actions)
         return list(CORE_ACTIONS)
 
     actions: set[str] = set(CORE_ACTIONS)
@@ -372,9 +395,24 @@ def get_available_actions_from_map(
             if cat and cat in loaded_categories:
                 actions.add(name)
 
+    # External MCP tools (mounted servers) — `mcp__<server>__<tool>` wire names
+    # fetched from GET /v1/agents/me/mcp/tools (client.list_mcp_tools()).
+    if external_actions:
+        actions.update(external_actions)
+
     return list(actions)
 
 
+def resolve_dispatch_tool_name(action_type: str) -> str:
+    """Resolve the gateway toolName for an action type.
+
+    Catalog actions dispatch as ``nookplot_<action_type>``; external MCP
+    tools are already fully-qualified ``mcp__<server>__<tool>`` registry names
+    and pass through unprefixed.
+    """
+    return action_type if action_type.startswith("mcp__") else f"nookplot_{action_type}"
+
+
 # ── Category Helpers ──
 
 def get_category_listing() -> list[dict[str, int | str]]:

{nookplot_runtime-0.5.129 → nookplot_runtime-0.5.131}/pyproject.toml

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

nookplot_runtime-0.5.131/tests/test_bounty_create.py

@@ -0,0 +1,88 @@
+"""Tests for _BountyManager.create — GitHub issue linkage pass-through
+(ROADMAP_github-issue-bounties, SDK create() wrapper params).
+
+The wrapper is a thin pass-through: it forwards the optional github_repo_url +
+github_issue_numbers to the prepare body and lets the gateway re-fetch issues
+and enforce the both-or-neither rule (D4). These tests pin that the fields reach
+the body when present and are omitted when absent.
+"""
+
+from typing import Any
+
+import pytest
+
+from nookplot_runtime.client import _BountyManager
+
+BASE: dict[str, Any] = {
+    "title": "Fix the race",
+    "description": "There is a race in the settlement loop.",
+    "community": "nookplot",
+    "deadline": "2030-01-01T00:00:00Z",
+    "token_reward_amount": 5_000_000,
+}
+
+
+def _make_manager() -> tuple[_BountyManager, list[dict[str, Any]]]:
+    """A manager whose _prepare_sign_relay just captures the body it was sent."""
+    captured: list[dict[str, Any]] = []
+    mgr = _BountyManager(http=None, sign_and_relay=None)  # type: ignore[arg-type]
+
+    async def fake_psr(prepare_path: str, body: dict[str, Any]) -> dict[str, Any]:
+        assert prepare_path == "/v1/prepare/bounty"
+        captured.append(body)
+        return {"txHash": "0xabc"}
+
+    mgr._prepare_sign_relay = fake_psr  # type: ignore[method-assign]
+    return mgr, captured
+
+
+@pytest.mark.asyncio
+async def test_threads_github_fields_into_body() -> None:
+    mgr, captured = _make_manager()
+    await mgr.create(
+        **BASE,
+        github_repo_url="https://github.com/owner/repo",
+        github_issue_numbers=[42, 137],
+    )
+    body = captured[0]
+    assert body["githubRepoUrl"] == "https://github.com/owner/repo"
+    assert body["githubIssueNumbers"] == [42, 137]
+
+
+@pytest.mark.asyncio
+async def test_omits_github_fields_when_absent() -> None:
+    mgr, captured = _make_manager()
+    await mgr.create(**BASE)
+    body = captured[0]
+    assert "githubRepoUrl" not in body
+    assert "githubIssueNumbers" not in body
+    assert body["title"] == BASE["title"]
+    assert body["tokenRewardAmount"] == BASE["token_reward_amount"]
+
+
+@pytest.mark.asyncio
+async def test_forwards_lone_repo_without_guard() -> None:
+    # No client-side guard — the gateway enforces both-or-neither (returns 400).
+    mgr, captured = _make_manager()
+    await mgr.create(**BASE, github_repo_url="owner/repo")
+    body = captured[0]
+    assert body["githubRepoUrl"] == "owner/repo"
+    assert "githubIssueNumbers" not in body
+
+
+@pytest.mark.asyncio
+async def test_threads_project_link_into_body() -> None:
+    mgr, captured = _make_manager()
+    await mgr.create(**BASE, project_id="my-project", task_id="task-uuid")
+    body = captured[0]
+    assert body["projectId"] == "my-project"
+    assert body["taskId"] == "task-uuid"
+
+
+@pytest.mark.asyncio
+async def test_omits_project_link_when_absent() -> None:
+    mgr, captured = _make_manager()
+    await mgr.create(**BASE)
+    body = captured[0]
+    assert "projectId" not in body
+    assert "taskId" not in body

nookplot_runtime-0.5.131/tests/test_external_mcp_tools.py

@@ -0,0 +1,90 @@
+"""External MCP tool wiring (ROADMAP_external-mcp-connectors Phase 1).
+
+Mounted servers' tools surface in the available-actions set and dispatch
+unprefixed as ``mcp:<server>:<tool>``.
+"""
+from nookplot_runtime.action_catalog import ACTION_CATALOG
+from nookplot_runtime.autonomous import get_available_actions
+from nookplot_runtime.signal_action_map import (
+    CORE_ACTIONS,
+    get_available_actions_from_map,
+    resolve_dispatch_tool_name,
+)
+
+EXTERNAL = ["mcp__notion__search", "mcp__notion__create_page"]
+
+
+def test_map_merges_external_actions():
+    actions = get_available_actions_from_map("directive", set(), EXTERNAL)
+    assert "mcp__notion__search" in actions
+    assert "mcp__notion__create_page" in actions
+    for core in CORE_ACTIONS:
+        assert core in actions
+
+
+def test_module_fn_forwards_external_actions():
+    assert "mcp__notion__search" in get_available_actions("directive", None, EXTERNAL)
+    assert "mcp__notion__search" not in get_available_actions("directive")
+
+
+def test_progressive_disclosure_still_surfaces_external(monkeypatch):
+    monkeypatch.setenv("NOOKPLOT_PROGRESSIVE_DISCLOSURE", "1")
+    actions = get_available_actions_from_map("directive", set(), EXTERNAL)
+    assert "mcp__notion__search" in actions
+    assert len(actions) == len(CORE_ACTIONS) + len(EXTERNAL)
+
+
+def test_resolve_dispatch_tool_name():
+    assert resolve_dispatch_tool_name("mcp__notion__search") == "mcp__notion__search"
+    assert resolve_dispatch_tool_name("send_message") == "nookplot_send_message"
+    assert resolve_dispatch_tool_name("create_post") == "nookplot_create_post"
+
+
+def test_dead_mcp_meta_actions_removed():
+    assert "call_mcp_tool" not in ACTION_CATALOG
+    assert "connect_mcp_server" not in ACTION_CATALOG
+    assert "disconnect_mcp_server" not in ACTION_CATALOG
+
+
+def test_connect_mcp_server_auth_kwargs():
+    """Phase 2: oauth / workspace auth fields reach the gateway body."""
+    import asyncio
+
+    from nookplot_runtime.client import _ToolManager
+
+    calls = []
+
+    class _FakeHttp:
+        async def request(self, method, path, body=None, **kwargs):
+            calls.append((method, path, body))
+            return {"data": {"id": "srv_1"}}
+
+    tools = _ToolManager(_FakeHttp())
+
+    asyncio.run(
+        tools.connect_mcp_server(
+            "https://mcp.notion.com/mcp",
+            "notion",
+            auth_type="oauth",
+            oauth_provider="notion",
+        )
+    )
+    assert calls[-1][2] == {
+        "serverUrl": "https://mcp.notion.com/mcp",
+        "serverName": "notion",
+        "authType": "oauth",
+        "oauthProvider": "notion",
+    }
+
+    asyncio.run(
+        tools.connect_mcp_server(
+            "https://mcp.notion.com/mcp",
+            "team-notion",
+            auth_type="workspace",
+            credential_service="notion",
+            workspace_id="11111111-2222-3333-4444-555555555555",
+        )
+    )
+    assert calls[-1][2]["authType"] == "workspace"
+    assert calls[-1][2]["credentialService"] == "notion"
+    assert calls[-1][2]["workspaceId"] == "11111111-2222-3333-4444-555555555555"

nookplot_runtime-0.5.131/tests/test_pack_gating.py

@@ -0,0 +1,69 @@
+"""Pack gating (ROADMAP_external-mcp-connectors Phase 3) — Python side.
+
+With ``pack_actions`` provided, the available-action surface resolves to
+CORE ∪ pack ∪ mounted external MCP tools in every disclosure mode. Mirrors
+the TS cases in runtime/src/__tests__/pack.gating.test.ts (the TS side is
+the parity source of truth; py exposure is via the module functions).
+"""
+from __future__ import annotations
+
+import os
+
+import pytest
+
+from nookplot_runtime.autonomous import get_available_actions
+from nookplot_runtime.signal_action_map import (
+    CORE_ACTIONS,
+    get_available_actions_from_map,
+)
+
+PACK_ACTIONS = ["search_knowledge", "send_email"]
+EXTERNAL = ["mcp__notion__search", "mcp__notion__create_page"]
+
+
+class TestPackGating:
+    def test_resolves_to_core_union_pack_union_external(self):
+        actions = get_available_actions_from_map("email_received", set(), EXTERNAL, PACK_ACTIONS)
+        for core in CORE_ACTIONS:
+            assert core in actions
+        assert "search_knowledge" in actions
+        assert "mcp__notion__search" in actions
+        # email_received's signal-context action reply_email is not in the pack.
+        assert "reply_email" not in actions
+        assert len(set(actions)) == len(set(CORE_ACTIONS) | set(PACK_ACTIONS) | set(EXTERNAL))
+
+    def test_empty_pack_still_gates(self):
+        actions = get_available_actions_from_map("email_received", set(), EXTERNAL, [])
+        assert "reply_email" not in actions
+        assert "mcp__notion__search" in actions
+        assert len(actions) == len(CORE_ACTIONS) + len(EXTERNAL)
+
+    def test_none_pack_leaves_behavior_unchanged(self):
+        assert "reply_email" in get_available_actions_from_map("email_received", set(), None, None)
+        assert "reply_email" in get_available_actions_from_map("email_received", set())
+
+    def test_loaded_categories_do_not_widen_under_a_pack(self):
+        ungated = get_available_actions_from_map("directive", {"bounties"})
+        assert "create_bounty" in ungated
+        gated = get_available_actions_from_map("directive", {"bounties"}, None, PACK_ACTIONS)
+        assert "create_bounty" not in gated
+
+    def test_gates_identically_in_progressive_disclosure_mode(self):
+        os.environ["NOOKPLOT_PROGRESSIVE_DISCLOSURE"] = "1"
+        try:
+            actions = get_available_actions_from_map("directive", set(), EXTERNAL, PACK_ACTIONS)
+            assert "search_knowledge" in actions
+            assert "mcp__notion__create_page" in actions
+            assert len(set(actions)) == len(set(CORE_ACTIONS) | set(PACK_ACTIONS) | set(EXTERNAL))
+        finally:
+            del os.environ["NOOKPLOT_PROGRESSIVE_DISCLOSURE"]
+
+    def test_module_level_get_available_actions_forwards(self):
+        gated = get_available_actions("email_received", pack_actions=PACK_ACTIONS)
+        assert "reply_email" not in gated
+        assert "search_knowledge" in gated
+        assert "reply_email" in get_available_actions("email_received")
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])

{nookplot_runtime-0.5.129 → nookplot_runtime-0.5.131}/tests/test_workspace_opportunity.py

@@ -60,6 +60,23 @@ def _events(activity: MagicMock) -> list[str]:
     return [c[0][0] for c in activity.call_args_list]
 
 
+# ── Bounty team teaser (Unit A A3) ────────────────────────────────────────────
+
+
+class TestBountyTeamTeaser:
+    @pytest.mark.asyncio
+    async def test_bounty_linked_workspace_surfaces_bounty_in_prompt(self):
+        _agent, captured, gen, _activity = _make_agent()
+        await _send_workspace(captured, sourceType="bounty", sourceRef="104")
+        assert "open bounty #104" in _prompt_of(gen)
+
+    @pytest.mark.asyncio
+    async def test_non_bounty_workspace_has_no_bounty_line(self):
+        _agent, captured, gen, _activity = _make_agent()
+        await _send_workspace(captured)
+        assert "open bounty #" not in _prompt_of(gen)
+
+
 # ── Decision parsing: INTERESTED vs SKIP ──────────────────────────────────────