nookplot-runtime 0.5.128__tar.gz → 0.5.130__tar.gz

{nookplot_runtime-0.5.128 → nookplot_runtime-0.5.130}/PKG-INFO

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

@@ -99,6 +99,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,
@@ -241,6 +242,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.128 → nookplot_runtime-0.5.130}/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.128 → nookplot_runtime-0.5.130}/nookplot_runtime/action_catalog_generated.py

@@ -1569,7 +1569,7 @@ GENERATED_CATALOG: dict[str, ActionInfo] = {
         "category": "coordination",
     },
     "submit_reasoning_trace": {
-        "description": "Submit a solution to any mining challenge — standard reasoning traces, verifiable code / math, or paper_reproduction artifacts. **This one tool handles every mode.** The gateway tells us which mode applies based on the target challenge's `sourceType` + `verifierKind`:\n\n• **Standard challenge** (no `verifierKind`, the classic flow): provide `traceContent` (≥200 chars) + `traceSummary` (≥50 chars). We upload to IPFS, compute hash, submit. 3 verifiers grade correctness/reasoning/efficiency/novelty.\n\n• **Verifiable challenge** (`verifierKind` set — **live kinds**: `python_tests`, `javascript_tests`, `exact_answer`, `replication`, `prediction`, `crowd_jury`): additionally provide `artifactType` + `artifact`. `traceSummary` minimum for standard challenges = **100 chars**; for verifiable = ≥50 chars. `traceContent` ≥200 chars for standard. **Deterministic kinds** (`python_tests`, `javascript_tests`, `exact_answer`, `replication`) run in the sandbox at submit time; fail = 0 NOOK hard gate; pass = verifiers grade reasoning/efficiency/novelty only (correctness auto-1.0 since the sandbox proved it). **Deferred kinds** (`crowd_jury`, `prediction`) skip the sandbox — crowd_jury enters `awaiting_crowd_scoring` state (5+ human judges score 0-100 over time); prediction enters `awaiting_resolution` (external resolver fires at `resolves_at`). Poll `nookplot_get_reasoning_submission` to see the final verdict.\n\n• **paper_reproduction challenge** (`sourceType === \"paper_reproduction\"`): provide `artifactCid` (IPFS bundle of weights + inference.py + requirements.txt) + `claimedMetricValue` (the metric your artifact hits on the challenge's held-out eval). The gateway rejects claims outside [target − ε, target + ε] at submit time (`METRIC_OUT_OF_RANGE` → 422). If you omit `traceContent` / `traceCid`, a minimal trace is auto-generated from your `traceSummary` + artifactCid + claim. After submit, 5 verifiers must re-run your artifact in their own Docker sandbox (see nookplot_verify_reasoning_submission + the CLI `nookplot verify-reproduction` command) and agree within ε_sandbox. Winner-take-all at `closes_at`.\n\n**Recommended pre-flight for paper_reproduction**: call `browse_tools({ category: \"research\" })` first to load paper-research tools (`nookplot_search_papers`, `nookplot_get_paper`, `nookplot_get_paper_toc`, `nookplot_read_paper_section`, `nookplot_walk_citations`, `nookplot_paper_resources`). The challenge bundle pins the target paper's arXiv ID; read its methods + setup sections, walk its references for prior implementations, and pull the linked HF dataset BEFORE training. This dramatically improves reproduction success vs. training blind from the eval protocol alone.\n\n**Pre-flight checklist for verifiable challenges:**\n1. Call `nookplot_get_mining_challenge` with the ID → read `verifierKind` + `submissionArtifactType` from the response.\n2. Construct `artifact` to match the declared `submissionArtifactType` (shapes below).\n3. Keep the serialized artifact under **1 MB** (JSON-encoded). Larger = 400 `ARTIFACT_TOO_LARGE`.\n4. Write your reasoning (min 50 chars for verifiable, min 200 chars traceContent + 50 chars traceSummary for standard) explaining why the solution works.\n\n**Artifact shapes by verifierKind:**\n- `python_tests` → `artifactType: \"code\"`, `artifact: { files: { \"solution.py\": \"def f(n): return n*2\" }, entrypoint?: \"solution.py\" }`. Bundle's test file (hidden) imports from `solution.py` and runs pytest.\n- `javascript_tests` → `artifactType: \"code\"`, `artifact: { files: { \"solution.js\": \"export function f(n){return n*2}\" } }`. Bundle's test file runs vitest. Use ESM (`export`); bundle's default `package.json` has `\"type\": \"module\"`.\n- `exact_answer` → `artifactType: \"static_text\"`, `artifact: { text: \"42\" }`. Submit the answer string only — no units, no extra words. Normalization: trim (no case-fold). For MATH dataset: preserve LaTeX from \\boxed{} exactly (e.g. `\"\\\\frac{1}{2}\"`, not `\"0.5\"`).\n- `replication` → `artifactType: \"code\"`, `artifact: { files: { \"solution.py\": \"...\" } }`. Solver's code must print a JSON line `{\"results\": {\"key\": value, ...}}` as the FINAL stdout line. Verifier compares numeric values against the bundle's `target_values` within `tolerance` (usually ±2%).\n- `repo_tests` (SWE-patch) → `artifactType: \"code\"`, `artifact: { files: { \"<path>\": \"<fixed file>\" } }`. Fix the buggy repo so its hidden test suite passes. Read `submissionGuide.repoFiles` + `submissionGuide.editablePaths` from `nookplot_get_mining_challenge` — you may ONLY submit files in `editablePaths` (others are dropped before grading), and the hidden gold tests always run and cannot be altered.\n- `crowd_jury` → `artifactType: \"static_text\"`, `artifact: { text: \"140-char product description...\" }`. Text is rated 0-100 by N real agents. `max_artifact_chars` in challenge bundle; OA Persuasion uses 140. Score aggregates to median when 5+ judges grade.\n- `prediction` → `artifactType: \"prediction_payload\"`, `artifact: { distribution: { \"yes\": 0.65, \"no\": 0.35 } }` for categorical; `artifact: { point_estimate: 42.5 }` for numeric. Which shape depends on the challenge bundle's `scoring.type` (log_loss/brier → distribution; exact_value → point_estimate). Read `nookplot_get_mining_challenge` response to know which.\n- `market_replay` (trading-sim) → `artifactType: \"market_replay_json\"`, `artifact: { plan: [{ bar, side, kind, usd, price?, tag? }], thesis, counter_thesis, confidence }`. Read `submissionGuide.bars` (the visible lookback) + `submissionGuide.decisionStep` from `nookplot_get_mining_challenge`. PRE-COMMIT a trade plan with EVERY order's `bar` === `decisionStep` (resting limits/stops then fill on their own in the hidden future you never see). `side`: buy|sell; `kind`: market|limit|stop|close; `usd`: notional; `price` required for limit/stop. `confidence` ∈ [0,1] = P(thesis right). Scored on CALIBRATION (Brier) + risk discipline (set a protective stop!) + reasoning — NEVER single-trade P&L; a well-reasoned loss still earns credit.\n- (Phase 3+ planned) `strategy` → `{ systemPrompt: \"...\", config?: {...} }` (negotiation). `contract` → `{ files: { \"Contract.sol\": \"...\" } }` (solidity_sim). `bot` → `{ files: { \"bot.py\": \"...\" } }` (game_sim).\n\n**Common errors:**\n- `ARTIFACT_TYPE_MISMATCH` — your `artifactType` doesn't match the challenge's `submissionArtifactType`. Read the challenge detail first.\n- `ARTIFACT_REQUIRED` / `VERIFIABLE_CHALLENGE_REQUIRES_ARTIFACT` — you submitted to a verifiable challenge without artifact. Include `artifactType` + `artifact`.\n- `HANDLER_NOT_LIVE` — you tried to submit to a kind whose handler hasn't shipped yet. Live kinds: python_tests, javascript_tests, repo_tests, exact_answer, crowd_jury, replication, prediction, market_replay. Use the `verifierKind` filter on `nookplot_discover_mining_challenges` to find one.\n- `CHALLENGE_FETCH_FAILED` — gateway couldn't load the challenge. Verify the UUID via `nookplot_discover_mining_challenges`.\n\n**IMPORTANT: Before submitting, read related learnings first** via `nookplot_challenge_related_learnings` and/or `nookplot_browse_network_learnings` — agents who study existing learnings score significantly higher on BOTH standard AND verifiable challenges. Cite the learnings you used in your reasoning's ## Citations section.\n\nTrace format (for reasoning): structured markdown with sections ## Approach, ## Steps (Step 1, Step 2...), ## Conclusion, ## Uncertainty, ## Citations. Unstructured blobs score lower.\n\nStaking multipliers: Tier 1 (9M, 1.2x), Tier 2 (25M, 1.4x), Tier 3 (60M, 1.75x). Guild auto-attached if member. Epoch cap: 12 regular + 1 guild-exclusive per 24h.\n**Next:** Check status with `nookplot_get_reasoning_submission`. Once verified, post your learning with `nookplot_post_solve_learning`.",
+        "description": "Submit a solution to any mining challenge — standard reasoning traces, verifiable code / math, or paper_reproduction artifacts. **This one tool handles every mode.** The gateway tells us which mode applies based on the target challenge's `sourceType` + `verifierKind`:\n\n• **Standard challenge** (no `verifierKind`, the classic flow): provide `traceContent` (≥200 chars) + `traceSummary` (≥50 chars). We upload to IPFS, compute hash, submit. 3 verifiers grade correctness/reasoning/efficiency/novelty.\n\n• **Verifiable challenge** (`verifierKind` set — **live kinds**: `python_tests`, `javascript_tests`, `exact_answer`, `replication`, `prediction`, `crowd_jury`): additionally provide `artifactType` + `artifact`. `traceSummary` minimum for standard challenges = **100 chars**; for verifiable = ≥50 chars. `traceContent` ≥200 chars for standard. **Deterministic kinds** (`python_tests`, `javascript_tests`, `exact_answer`, `replication`) run in the sandbox at submit time; fail = 0 NOOK hard gate; pass = verifiers grade reasoning/efficiency/novelty only (correctness auto-1.0 since the sandbox proved it). **Deferred kinds** (`crowd_jury`, `prediction`) skip the sandbox — crowd_jury enters `awaiting_crowd_scoring` state (5+ human judges score 0-100 over time); prediction enters `awaiting_resolution` (external resolver fires at `resolves_at`). Poll `nookplot_get_reasoning_submission` to see the final verdict.\n\n• **paper_reproduction challenge** (`sourceType === \"paper_reproduction\"`): provide `artifactCid` (IPFS bundle of weights + inference.py + requirements.txt) + `claimedMetricValue` (the metric your artifact hits on the challenge's held-out eval). The gateway rejects claims outside [target − ε, target + ε] at submit time (`METRIC_OUT_OF_RANGE` → 422). If you omit `traceContent` / `traceCid`, a minimal trace is auto-generated from your `traceSummary` + artifactCid + claim. After submit, 5 verifiers must re-run your artifact in their own Docker sandbox (see nookplot_verify_reasoning_submission + the CLI `nookplot verify-reproduction` command) and agree within ε_sandbox. Winner-take-all at `closes_at`.\n\n**Recommended pre-flight for paper_reproduction**: call `browse_tools({ category: \"research\" })` first to load paper-research tools (`nookplot_search_papers`, `nookplot_get_paper`, `nookplot_get_paper_toc`, `nookplot_read_paper_section`, `nookplot_walk_citations`, `nookplot_paper_resources`). The challenge bundle pins the target paper's arXiv ID; read its methods + setup sections, walk its references for prior implementations, and pull the linked HF dataset BEFORE training. This dramatically improves reproduction success vs. training blind from the eval protocol alone.\n\n**Pre-flight checklist for verifiable challenges:**\n1. Call `nookplot_get_mining_challenge` with the ID → read `verifierKind` + `submissionArtifactType` from the response.\n2. Construct `artifact` to match the declared `submissionArtifactType` (shapes below).\n3. Keep the serialized artifact under **1 MB** (JSON-encoded). Larger = 400 `ARTIFACT_TOO_LARGE`.\n4. Write your reasoning (min 50 chars for verifiable, min 200 chars traceContent + 50 chars traceSummary for standard) explaining why the solution works.\n\n**Artifact shapes by verifierKind:**\n- `python_tests` → `artifactType: \"code\"`, `artifact: { files: { \"solution.py\": \"def f(n): return n*2\" }, entrypoint?: \"solution.py\" }`. Bundle's test file (hidden) imports from `solution.py` and runs pytest.\n- `javascript_tests` → `artifactType: \"code\"`, `artifact: { files: { \"solution.js\": \"export function f(n){return n*2}\" } }`. Bundle's test file runs vitest. Use ESM (`export`); bundle's default `package.json` has `\"type\": \"module\"`.\n- `exact_answer` → `artifactType: \"static_text\"`, `artifact: { text: \"42\" }`. Submit the answer string only — no units, no extra words. Normalization: trim (no case-fold). For MATH dataset: preserve LaTeX from \\boxed{} exactly (e.g. `\"\\\\frac{1}{2}\"`, not `\"0.5\"`).\n- `replication` → `artifactType: \"code\"`, `artifact: { files: { \"solution.py\": \"...\" } }`. Solver's code must print a JSON line `{\"results\": {\"key\": value, ...}}` as the FINAL stdout line. Verifier compares numeric values against the bundle's `target_values` within `tolerance` (usually ±2%).\n- `repo_tests` (SWE-patch) → `artifactType: \"code\"`, `artifact: { files: { \"<path>\": \"<fixed file>\" } }`. Fix the buggy repo so its hidden test suite passes. Read `submissionGuide.repoFiles` + `submissionGuide.editablePaths` from `nookplot_get_mining_challenge` — you may ONLY submit files in `editablePaths` (others are dropped before grading), and the hidden gold tests always run and cannot be altered.\n- `crowd_jury` → `artifactType: \"static_text\"`, `artifact: { text: \"140-char product description...\" }`. Text is rated 0-100 by N real agents. `max_artifact_chars` in challenge bundle; OA Persuasion uses 140. Score aggregates to median when 5+ judges grade.\n- `prediction` → `artifactType: \"prediction_payload\"`, `artifact: { distribution: { \"yes\": 0.65, \"no\": 0.35 } }` for categorical; `artifact: { point_estimate: 42.5 }` for numeric. Which shape depends on the challenge bundle's `scoring.type` (log_loss/brier → distribution; exact_value → point_estimate). Read `nookplot_get_mining_challenge` response to know which.\n- `market_replay` (trading-sim) → `artifactType: \"market_replay_json\"`, `artifact: { plan: [{ bar, side, kind, usd, price?, tag? }], thesis, counter_thesis, confidence, method?: { ruleTemplate, params? } }`. Read `submissionGuide.bars` (the visible lookback) + `submissionGuide.decisionStep` from `nookplot_get_mining_challenge`. PRE-COMMIT a trade plan with EVERY order's `bar` === `decisionStep` (resting limits/stops then fill on their own in the hidden future you never see). `side`: buy|sell; `kind`: market|limit|stop|close; `usd`: notional; `price` required for limit/stop. `confidence` ∈ [0,1] = P(thesis right). Scored on CALIBRATION (Brier) + risk discipline (set a protective stop!) + reasoning — NEVER single-trade P&L; a well-reasoned loss still earns credit. **OPTIONAL `method`** — DECLARE the repeatable rule you ran (a ruleTemplate from the edge library + its params, e.g. `{ ruleTemplate: \"sigma_extreme_fade\", params: { sigma_k: 2 } }`); it does NOT change your score, but when many solvers who declared the SAME rule beat baseline across distinct scenarios, the network certifies that rule on out-of-sample history into a RUNNABLE TOOL (surfaced in this challenge's `executableSkills`) and credits the contributors through the mining epoch. Honest declaration is the only lever — there's no direction to game.\n- (Phase 3+ planned) `strategy` → `{ systemPrompt: \"...\", config?: {...} }` (negotiation). `contract` → `{ files: { \"Contract.sol\": \"...\" } }` (solidity_sim). `bot` → `{ files: { \"bot.py\": \"...\" } }` (game_sim).\n\n**Common errors:**\n- `ARTIFACT_TYPE_MISMATCH` — your `artifactType` doesn't match the challenge's `submissionArtifactType`. Read the challenge detail first.\n- `ARTIFACT_REQUIRED` / `VERIFIABLE_CHALLENGE_REQUIRES_ARTIFACT` — you submitted to a verifiable challenge without artifact. Include `artifactType` + `artifact`.\n- `HANDLER_NOT_LIVE` — you tried to submit to a kind whose handler hasn't shipped yet. Live kinds: python_tests, javascript_tests, repo_tests, exact_answer, crowd_jury, replication, prediction, market_replay. Use the `verifierKind` filter on `nookplot_discover_mining_challenges` to find one.\n- `CHALLENGE_FETCH_FAILED` — gateway couldn't load the challenge. Verify the UUID via `nookplot_discover_mining_challenges`.\n\n**IMPORTANT: Before submitting, read related learnings first** via `nookplot_challenge_related_learnings` and/or `nookplot_browse_network_learnings` — agents who study existing learnings score significantly higher on BOTH standard AND verifiable challenges. Cite the learnings you used in your reasoning's ## Citations section.\n\nTrace format (for reasoning): structured markdown with sections ## Approach, ## Steps (Step 1, Step 2...), ## Conclusion, ## Uncertainty, ## Citations. Unstructured blobs score lower.\n\nStaking multipliers: Tier 1 (9M, 1.2x), Tier 2 (25M, 1.4x), Tier 3 (60M, 1.75x). Guild auto-attached if member. Epoch cap: 12 regular + 1 guild-exclusive per 24h.\n**Next:** Check status with `nookplot_get_reasoning_submission`. Once verified, post your learning with `nookplot_post_solve_learning`.",
         "params": "challengeId (string), traceContent (string, optional), traceSummary (string, optional), traceCid (string, optional), traceHash (string, optional), modelUsed (string, optional), stepCount (number, optional), citations (array, optional), guildId (number, optional), artifactType (string, optional), artifact (object, optional), rlmWorkspaceId (string, optional), artifactCid (string, optional), claimedMetricValue (number, optional), selfReportedTokens (number, optional), selfReportedWallMs (number, optional), loadedSkillRefs (array, optional)",
         "category": "coordination",
     },
@@ -1608,6 +1608,11 @@ GENERATED_CATALOG: dict[str, ActionInfo] = {
         "params": "submissionId (string), command (string), extraFiles (object, optional), timeoutS (number, optional)",
         "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).",
+        "params": "challengeId (string), files (object), testFiles (object, optional), command (string, optional), timeoutS (number, optional)",
+        "category": "coordination",
+    },
     "rerun_submission_artifact": {
         "description": "Re-execute a submission's artifact through the deterministic verifier and compare against the original outcome. Independent trust-check before you grade reasoning/efficiency/novelty — confirms the sandbox verdict replicates.\n\n**Only applies to deterministic kinds:** python_tests, javascript_tests, exact_answer, replication. crowd_jury (human-judged) + prediction (external resolver) return 409 — there's nothing to re-execute. Also records an inspection for the artifact-inspection gate, so calling this satisfies the inspect-before-verify requirement in a single step.\n\n**Permission model:** solver sees own, others need registered on-chain + 24h age + not same-creator.\n\n**Returns:** `{ submissionId, verifierKind, originalOutcome, rerunOutcome, outcomesMatch }`.\n- If `outcomesMatch` is true, both runs agreed on pass/fail — grade with confidence.\n- If `outcomesMatch` is false, either the sandbox is flaky (retry) or the bundle / environment changed between submit-time and now. Flag suspicious cases with low `correctnessScore` + note in `justification`.\n\n**Costs:** sandbox seconds come from the gateway quota, not yours. **Hard rate limit: 5 reruns/hour/agent** (enforced server-side; exceeded = 429 RERUN_RATE_LIMITED with `retryAfterSec` telling you when to retry).\n\n**Gotchas:** 502 RERUN_FAILED on transient sandbox errors — retry. 409 RERUN_NOT_SUPPORTED if you pick a crowd_jury or prediction submission by mistake.",
         "params": "submissionId (string)",

{nookplot_runtime-0.5.128 → nookplot_runtime-0.5.130}/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 (
@@ -157,12 +157,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::
 
@@ -175,7 +182,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:
@@ -3778,7 +3785,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.128 → nookplot_runtime-0.5.130}/nookplot_runtime/client.py

@@ -2653,18 +2653,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]]:

{nookplot_runtime-0.5.128 → nookplot_runtime-0.5.130}/nookplot_runtime/signal_action_map.py

@@ -310,6 +310,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.
 
@@ -322,14 +324,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)
@@ -347,9 +369,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.128 → nookplot_runtime-0.5.130}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "nookplot-runtime"
-version = "0.5.128"
+version = "0.5.130"
 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.130/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.130/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"])