@ponythewhite/base-context 1.0.1 → 1.0.4

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## [1.0.4] - 2026-09-17
+
+- Fixed first-time Python setup failing to find its newly installed uv when XDG data paths are configured.
+
+## [1.0.3] - 2026-09-17
+
+- Fixed late OAuth and API-key logins overwriting a newer login or undoing logout.
+- Fixed configured MCP environment-token authentication falling back to stored credentials.
+- Fixed MCP tool discovery to retrieve paginated inventories without partial results and protect cached schemas from caller edits.
+- Masked API-key prompts and pasted sign-in codes and callback values while keeping browser sign-in links readable.
+- Fixed provider logout reporting success when saved credentials could not be removed.
+- Fixed shutdown admission loss after slow process scans or transient registry errors while the shutdown process still owns its record.
+- Fixed source builds including the development Python virtual environment in release packages.
+
+## [1.0.2] - 2026-09-17
+
+- Fixed RPC requests waiting for a timeout after the agent process exits, and removed the shutdown delay for an already-exited process.
+
 ## [1.0.1] - 2026-09-16
 
 - Made the Synerise base-context installer the primary setup path, with automatic prerequisites, optional shell-profile updates, and clear launch instructions.

package/dist/base-context-runtime/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "base-context-runtime"
-version = "1.0.1"
+version = "1.0.4"
 description = "Kernel-side runtime shim for Base Context recursion"
 license = "MIT"
 license-files = ["LICENSE", "NOTICE"]

package/dist/base-context-runtime/src/rlm/mcp.py

@@ -10,6 +10,7 @@ import re
 import threading
 import time
 from contextlib import AsyncExitStack
+from copy import deepcopy
 from collections.abc import Awaitable, Callable
 from typing import Any, TypeVar
 
@@ -20,6 +21,7 @@ __all__ = ["McpStartupError", "call_tool", "close", "list_tools", "reload"]
 
 _DEFAULT_STARTUP_TIMEOUT = 20.0
 _DEFAULT_CALL_TIMEOUT = 60.0
+_MAX_TOOL_LIST_PAGES = 100
 # Must stay strictly below the host's KERNEL_SHUTDOWN_TIMEOUT_MS (5s) kill deadline.
 _SHUTDOWN_TIMEOUT = 2.5
 _T = TypeVar("_T")
@@ -259,21 +261,41 @@ class _Generation:
         return await self.stack.enter_async_context(stdio_client(params, errlog=self._stderr))
 
     async def discover(self) -> None:
-        response = await self.session.list_tools()
+        from mcp.types import PaginatedRequestParams
+
         tools: dict[str, dict[str, Any]] = {}
-        for tool in response.tools:
-            name = getattr(tool, "name", None)
-            if not isinstance(name, str):
-                continue
-            schema = getattr(tool, "input_schema", None)
-            if schema is None:
-                schema = getattr(tool, "inputSchema", None)
-            tools[name] = {
-                "name": name,
-                "description": getattr(tool, "description", "") or "",
-                "inputSchema": schema if isinstance(schema, dict) else {},
-            }
-        self.tools = tools
+        cursor: str | None = None
+        seen_cursors: set[str] = set()
+        for _ in range(_MAX_TOOL_LIST_PAGES):
+            response = (
+                await self.session.list_tools()
+                if cursor is None
+                else await self.session.list_tools(params=PaginatedRequestParams(cursor=cursor))
+            )
+            for tool in response.tools:
+                name = getattr(tool, "name", None)
+                if not isinstance(name, str):
+                    continue
+                schema = getattr(tool, "input_schema", None)
+                if schema is None:
+                    schema = getattr(tool, "inputSchema", None)
+                tools[name] = {
+                    "name": name,
+                    "description": getattr(tool, "description", "") or "",
+                    "inputSchema": schema if isinstance(schema, dict) else {},
+                }
+            cursor = getattr(response, "next_cursor", None)
+            if cursor is None:
+                cursor = getattr(response, "nextCursor", None)
+            if cursor is None:
+                self.tools = tools
+                return
+            if not isinstance(cursor, str):
+                raise RuntimeError(f"MCP server '{self.server}' returned an invalid tools/list cursor")
+            if cursor in seen_cursors:
+                raise RuntimeError(f"MCP server '{self.server}' repeated a tools/list cursor")
+            seen_cursors.add(cursor)
+        raise RuntimeError(f"MCP server '{self.server}' exceeded the tools/list page limit")
 
     def allows(self, tool: str) -> bool:
         enabled = self.config.get("enabledTools")
@@ -379,7 +401,7 @@ class _Registry:
     async def tools(self, server: str) -> list[dict[str, Any]]:
         async def operation() -> list[dict[str, Any]]:
             generation = await self._get(server)
-            return [dict(tool) for name, tool in generation.tools.items() if generation.allows(name)]
+            return [deepcopy(tool) for name, tool in generation.tools.items() if generation.allows(name)]
 
         return await self._tracked(operation)
 
@@ -529,7 +551,7 @@ def _bound_auth(provider: str, config: dict[str, Any]) -> dict[str, Any] | None:
 async def _auth_identity(server: str, config: dict[str, Any]) -> str:
     env_name = config.get("bearerTokenEnvVar")
     token = os.environ.get(env_name, "").strip() if isinstance(env_name, str) else ""
-    if config.get("oauth") is True and not token:
+    if config.get("oauth") is True and not env_name:
         provider = f"mcp:{server}"
         cred = _bound_auth(provider, config)
         expires = (cred or {}).get("expires")
@@ -556,7 +578,7 @@ async def _headers(server: str, config: dict[str, Any]) -> dict[str, str]:
         return headers
     env_name = config.get("bearerTokenEnvVar")
     token = os.environ.get(env_name, "").strip() if isinstance(env_name, str) else ""
-    if config.get("oauth") is True and not token:
+    if config.get("oauth") is True and not env_name:
         cred = _bound_auth(f"mcp:{server}", config)
         token = _resolve_config_value(str((cred or {}).get("access") or (cred or {}).get("key") or ""))
     if token:

package/dist/base-context-runtime/test/test_mcp.py

@@ -15,7 +15,7 @@ from pathlib import Path
 from types import SimpleNamespace
 from unittest import mock
 
-from mcp.types import CallToolResult, TextContent
+from mcp.types import CallToolResult, PaginatedRequestParams, TextContent
 from rlm import McpToolError, mcp
 from rlm.mcp_base import _parse_result
 
@@ -104,6 +104,55 @@ class McpRegistryTest(unittest.TestCase):
         generation = self.generation({"type": "http"}, [tool])
         self.assertEqual(generation.tools["raw.tool/name"]["inputSchema"], schema)
 
+    def test_listing_detaches_nested_cached_schemas(self):
+        schema = {"type": "object", "properties": {"x": {"enum": ["original"]}}}
+        generation = self.generation({"type": "http"}, [SimpleNamespace(name="tool", inputSchema=schema)])
+
+        async def scenario():
+            with mock.patch.object(mcp._registry, "_get_locked", mock.AsyncMock(return_value=generation)):
+                first = await mcp.list_tools("svc")
+                first[0]["inputSchema"]["properties"]["x"]["enum"].append("caller mutation")
+                second = await mcp.list_tools("svc")
+                self.assertEqual(second[0]["inputSchema"], schema)
+                self.assertEqual(schema["properties"]["x"]["enum"], ["original"])
+
+        run(scenario())
+
+    def test_discovers_all_pages_with_sdk_params_and_cursor_aliases(self):
+        generation = mcp._Generation("svc", {"type": "http"})
+        generation.session = SimpleNamespace(list_tools=mock.AsyncMock(side_effect=[
+            SimpleNamespace(tools=[SimpleNamespace(name="first")], next_cursor=""),
+            SimpleNamespace(tools=[SimpleNamespace(name="second")], nextCursor="page-3"),
+            SimpleNamespace(tools=[SimpleNamespace(name="third")], next_cursor=None),
+        ]))
+        run(generation.discover())
+        self.assertEqual(list(generation.tools), ["first", "second", "third"])
+        self.assertEqual(generation.session.list_tools.call_args_list, [
+            mock.call(),
+            mock.call(params=PaginatedRequestParams(cursor="")),
+            mock.call(params=PaginatedRequestParams(cursor="page-3")),
+        ])
+
+    def test_failed_pagination_never_publishes_partial_inventory(self):
+        for case, cursors, message in (
+            ("cycle", ["repeat", "repeat"], "repeated"),
+            ("malformed", [17], "invalid"),
+            ("excessive", ["page-2", "page-3"], "page limit"),
+        ):
+            with self.subTest(case=case):
+                generation = self.generation({"type": "http"}, [SimpleNamespace(name="previous")])
+                previous = generation.tools
+                generation.session = SimpleNamespace(list_tools=mock.AsyncMock(side_effect=[
+                    SimpleNamespace(tools=[SimpleNamespace(name="partial")], next_cursor=cursor)
+                    for cursor in cursors
+                ]))
+                with mock.patch.object(mcp, "_MAX_TOOL_LIST_PAGES", 2):
+                    with self.assertRaisesRegex(RuntimeError, message):
+                        run(generation.discover())
+                self.assertIs(generation.tools, previous)
+                self.assertNotIn("partial", generation.tools)
+                self.assertLessEqual(generation.session.list_tools.call_count, 2)
+
     def test_sdk_result_aliases_preserve_structured_output_and_errors(self):
         structured = CallToolResult(content=[], structuredContent={})
         self.assertEqual(_parse_result(structured), {})
@@ -317,6 +366,43 @@ class McpRegistryTest(unittest.TestCase):
             env = mcp._stdio_env({"credentialSource": "acp", "env": {"TOKEN": "task-secret"}})
         self.assertEqual(env, {"PATH": "/bin", "TOKEN": "task-secret"})
 
+    def test_selected_environment_token_refuses_missing_values_before_connection(self):
+        config = {
+            "type": "http", "url": "https://srv.example/mcp", "oauth": True,
+            "bearerTokenEnvVar": "SELECTED_MCP_TOKEN",
+            "headers": {"Authorization": "Bearer configured-header"},
+        }
+        for token in (None, "", "  "):
+            with self.subTest(token=token), mock.patch.dict(
+                os.environ, {} if token is None else {"SELECTED_MCP_TOKEN": token}, clear=True
+            ), mock.patch.object(mcp, "host_request", new=mock.AsyncMock(return_value=config)) as request, mock.patch.object(
+                mcp, "_read_auth", side_effect=AssertionError("must not read stored OAuth")
+            ), mock.patch.object(mcp._Generation, "_open_http", new=mock.AsyncMock()) as connect:
+                with self.assertRaisesRegex(RuntimeError, "credentials.*not available"):
+                    run(mcp.list_tools("remote"))
+                with self.assertRaisesRegex(RuntimeError, "credentials.*not available"):
+                    run(mcp._headers("remote", config))
+                request.assert_awaited_once_with("mcp.config", {"server": "remote"})
+                connect.assert_not_called()
+                self.assertEqual(mcp._registry._generations, {})
+                mcp._registry = mcp._Registry()
+
+    def test_selected_environment_token_is_the_only_auth_source(self):
+        config = {
+            "oauth": True, "url": "https://srv.example/mcp", "bearerTokenEnvVar": "SELECTED_MCP_TOKEN",
+            "headers": {"Authorization": "Bearer configured-header", "X-Other": "keep"},
+        }
+        with mock.patch.dict(os.environ, {"SELECTED_MCP_TOKEN": "  selected-token  "}), mock.patch.object(
+            mcp, "_read_auth", side_effect=AssertionError("must not read stored OAuth")
+        ), mock.patch.object(mcp, "host_request", new=mock.AsyncMock()) as request:
+            identity = run(mcp._auth_identity("remote", config))
+            self.assertNotEqual(identity, "anonymous")
+            self.assertNotIn("selected-token", identity)
+            self.assertEqual(run(mcp._headers("remote", config)), {
+                "Authorization": "Bearer selected-token", "X-Other": "keep",
+            })
+            request.assert_not_called()
+
     def test_endpoint_bound_credential_never_attaches_to_another_url(self):
         cred = {"access": "old-token", "endpoint": "https://old.example/mcp"}
         config = {"oauth": True, "url": "https://new.example/mcp"}

package/dist/base-context-runtime/uv.lock

@@ -367,7 +367,7 @@ wheels = [
 
 [[package]]
 name = "base-context-runtime"
-version = "1.0.1"
+version = "1.0.4"
 source = { editable = "." }
 dependencies = [
     { name = "mcp" },

package/dist/build-info.json

@@ -1,5 +1,5 @@
 {
-  "sourceCommit": "9247ae92d4cc1a43fcb003316e6762be579a6a05",
+  "sourceCommit": "84d72c5846ae0d65614b6b2bf966c48dd18ad7aa",
   "sourceDirty": false,
   "buildHost": {
     "platform": "linux",

package/dist/bundle/{bundled-modules-TXUMJ2XQ.js → bundled-modules-R5EAJ62K.js}

@@ -51,7 +51,7 @@ import {
   oauth_exports,
   runPrintMode,
   runRpcMode
-} from "./chunk-S3INFPZZ.js";
+} from "./chunk-BV25CVRM.js";
 import {
   AgentSession,
   CURRENT_SESSION_VERSION,
@@ -143,7 +143,7 @@ import {
   withFileMutationQueue,
   wrapRegisteredTool,
   wrapRegisteredTools
-} from "./chunk-V3L54UD6.js";
+} from "./chunk-XDJ56NJA.js";
 import "./chunk-CFNASUYO.js";
 import "./chunk-HKINIBP4.js";
 import {