linc-cli-kit 0.1.3__tar.gz → 0.1.4__tar.gz

{linc_cli_kit-0.1.3 → linc_cli_kit-0.1.4}/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 All notable changes to linc-cli-kit are listed here.
 
+## [0.1.4]
+
+- `strict_tools(server, *, strict_types=False)`: rejects unknown MCP tool arguments. Every
+  registered tool's argument model gets `extra="forbid"` and its schema advertises
+  `additionalProperties: false`, including tools registered after the call. `strict_types=True`
+  also turns off lax type coercion. It raises `TypeError`, naming the change, if the MCP SDK
+  internals it relies on are missing. Exported as `linc_cli_kit.strict_tools`.
+- `assert_cli_parity` checks that MCP rejects an unknown argument, matching the CLI's exit-2
+  rejection of an unknown option.
+- Lint: ruff `S101` (no `assert` in library code) is on; tests are exempt.
+
 ## [0.1.3]
 
 - Tests: the JSON-mode heartbeat test also polls instead of a fixed sleep (the sibling of the

{linc_cli_kit-0.1.3 → linc_cli_kit-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: linc-cli-kit
-Version: 0.1.3
+Version: 0.1.4
 Summary: Reflect a FastMCP tool registry into Click commands under one agent-grade output contract
 Project-URL: Homepage, https://github.com/LincForge/cli-kit
 Project-URL: Issues, https://github.com/LincForge/cli-kit/issues
@@ -41,7 +41,7 @@ Save as `hello_cli.py`:
 import click
 from mcp.server.fastmcp import FastMCP
 
-from linc_cli_kit import LocalTransport, install_globals, mount_tools
+from linc_cli_kit import LocalTransport, install_globals, mount_tools, strict_tools
 
 server = FastMCP("hello")
 
@@ -52,6 +52,9 @@ def hello_greet(name: str, times: int = 1) -> dict:
     return {"greeting": " ".join([f"Hello, {name}!"] * times)}
 
 
+strict_tools(server)
+
+
 @click.group()
 def main() -> None:
     """hello: JSON on stdout by default, --human for text."""
@@ -86,7 +89,7 @@ import sys
 import click
 from linc_cli_kit import (
     HttpDaemonTransport, LocalTransport, configure_structlog_stderr,
-    install_globals, mount_tools,
+    install_globals, mount_tools, strict_tools,
 )
 
 configure_structlog_stderr()   # MUST be above your package imports — see below
@@ -94,6 +97,8 @@ configure_structlog_stderr()   # MUST be above your package imports — see belo
 from <tool>.mcp._core import server            # noqa: E402
 from <tool>.core.controller import Controller  # noqa: E402
 
+strict_tools(server)           # reject unknown MCP tool arguments (matches Click's CLI check)
+
 
 @click.group()
 def main() -> None:
@@ -147,6 +152,9 @@ def test_cli_parity() -> None:
 
 Rules the suite enforces, so read them before adding a command:
 
+- **Every FastMCP server must call `strict_tools(server)`.** FastMCP ignores unknown arguments by
+  default while Click rejects unknown options; the suite verifies that MCP rejects an unknown
+  argument (`extra="forbid"`) and advertises `additionalProperties: false` on every mounted tool.
 - **Every hand-written override needs a `samples[<tool_name>]` entry.** Without one the suite
   fails closed rather than silently skipping the override's JSON contract.
 - **Overrides must route through the group transport** (`ctx.find_root().command.linc_transport`),

{linc_cli_kit-0.1.3 → linc_cli_kit-0.1.4}/README.md

@@ -22,7 +22,7 @@ Save as `hello_cli.py`:
 import click
 from mcp.server.fastmcp import FastMCP
 
-from linc_cli_kit import LocalTransport, install_globals, mount_tools
+from linc_cli_kit import LocalTransport, install_globals, mount_tools, strict_tools
 
 server = FastMCP("hello")
 
@@ -33,6 +33,9 @@ def hello_greet(name: str, times: int = 1) -> dict:
     return {"greeting": " ".join([f"Hello, {name}!"] * times)}
 
 
+strict_tools(server)
+
+
 @click.group()
 def main() -> None:
     """hello: JSON on stdout by default, --human for text."""
@@ -67,7 +70,7 @@ import sys
 import click
 from linc_cli_kit import (
     HttpDaemonTransport, LocalTransport, configure_structlog_stderr,
-    install_globals, mount_tools,
+    install_globals, mount_tools, strict_tools,
 )
 
 configure_structlog_stderr()   # MUST be above your package imports — see below
@@ -75,6 +78,8 @@ configure_structlog_stderr()   # MUST be above your package imports — see belo
 from <tool>.mcp._core import server            # noqa: E402
 from <tool>.core.controller import Controller  # noqa: E402
 
+strict_tools(server)           # reject unknown MCP tool arguments (matches Click's CLI check)
+
 
 @click.group()
 def main() -> None:
@@ -128,6 +133,9 @@ def test_cli_parity() -> None:
 
 Rules the suite enforces, so read them before adding a command:
 
+- **Every FastMCP server must call `strict_tools(server)`.** FastMCP ignores unknown arguments by
+  default while Click rejects unknown options; the suite verifies that MCP rejects an unknown
+  argument (`extra="forbid"`) and advertises `additionalProperties: false` on every mounted tool.
 - **Every hand-written override needs a `samples[<tool_name>]` entry.** Without one the suite
   fails closed rather than silently skipping the override's JSON contract.
 - **Overrides must route through the group transport** (`ctx.find_root().command.linc_transport`),

{linc_cli_kit-0.1.3 → linc_cli_kit-0.1.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "linc-cli-kit"
-version = "0.1.3"
+version = "0.1.4"
 description = "Reflect a FastMCP tool registry into Click commands under one agent-grade output contract"
 requires-python = ">=3.12"
 license = "Apache-2.0"
@@ -50,6 +50,9 @@ select = [
     "RUF",
     "ANN",
 ]
+extend-select = [
+    "S101",
+]
 ignore = [
     "ANN401",
 ]
@@ -57,6 +60,19 @@ ignore = [
 [tool.ruff.lint.per-file-ignores]
 "tests/**" = [
     "ANN",
+    "S101",
+]
+"**/test_*.py" = [
+    "S101",
+]
+"**/*_test.py" = [
+    "S101",
+]
+"**/conftest.py" = [
+    "S101",
+]
+"**/testing.py" = [
+    "S101",
 ]
 
 [tool.pytest.ini_options]

{linc_cli_kit-0.1.3 → linc_cli_kit-0.1.4}/src/linc_cli_kit/__init__.py

@@ -17,7 +17,7 @@ from linc_cli_kit.mount import (
     mount_tools,
 )
 from linc_cli_kit.output import emit, emit_exception, heartbeat, json_default, to_json
-from linc_cli_kit.registry import ToolSpec, registry_of
+from linc_cli_kit.registry import ToolSpec, registry_of, strict_tools
 from linc_cli_kit.transport import HttpDaemonTransport, LocalTransport
 
 if TYPE_CHECKING:
@@ -46,6 +46,7 @@ __all__ = [
     "mount_tools",
     "parse_error_envelope",
     "registry_of",
+    "strict_tools",
     "to_json",
 ]
 

linc_cli_kit-0.1.4/src/linc_cli_kit/registry.py

@@ -0,0 +1,132 @@
+"""The only module allowed to touch FastMCP's private tool manager.
+
+`_tool_manager` is private SDK API (renamed in the SDK's v2 line). Everything
+else in the kit consumes ToolSpec, so an SDK change is fixed in one place.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import functools
+from collections.abc import Callable, Iterator
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass(frozen=True)
+class ToolSpec:
+    name: str
+    description: str
+    parameters: dict[str, Any]
+    fn: Callable[..., Any]
+    is_async: bool
+
+
+def _tool_manager(server: Any, caller: str) -> tuple[Any, Callable[[], list[Any]]]:
+    manager = getattr(server, "_tool_manager", None)
+    list_tools = getattr(manager, "list_tools", None)
+    if manager is None or not callable(list_tools):
+        raise TypeError(
+            f"{caller}() expects a FastMCP server with a FastMCP tool registry "
+            f"(_tool_manager.list_tools); got {type(server).__name__}"
+        )
+    return manager, list_tools
+
+
+def _harden_tool(tool: Any, *, strict_types: bool) -> None:
+    parameters = getattr(tool, "parameters", None)
+    if not isinstance(parameters, dict):
+        raise TypeError(
+            "FastMCP Tool lacks 'parameters' — SDK shape changed; update registry.py"
+        )
+    fn_metadata = getattr(tool, "fn_metadata", None)
+    arg_model = getattr(fn_metadata, "arg_model", None)
+    model_config = getattr(arg_model, "model_config", None)
+    model_rebuild = getattr(arg_model, "model_rebuild", None)
+    if (
+        fn_metadata is None
+        or arg_model is None
+        or not isinstance(model_config, dict)
+        or not callable(model_rebuild)
+    ):
+        raise TypeError(
+            "FastMCP Tool lacks 'fn_metadata.arg_model' — SDK shape changed; update registry.py"
+        )
+    model_config["extra"] = "forbid"
+    if strict_types:
+        model_config["strict"] = True
+    model_rebuild(force=True)
+    parameters["additionalProperties"] = False
+
+
+def strict_tools(server: Any, *, strict_types: bool = False) -> Any:
+    """Reject unknown MCP tool arguments (`extra='forbid'` + `additionalProperties: false`).
+
+    FastMCP's default argument model silently drops unknown keys, while Click rejects unknown
+    CLI options with exit code 2. Calling `strict_tools(server)` brings the MCP surface into
+    parity with the CLI contract and advertises `additionalProperties: false` via `list_tools()`.
+    Pass `strict_types=True` to also set Pydantic `strict=True` (disabling lax string-to-number
+    coercion).
+    """
+    manager, list_tools = _tool_manager(server, "strict_tools")
+    for tool in list_tools():
+        _harden_tool(tool, strict_types=strict_types)
+
+    add_tool = getattr(manager, "_linc_orig_add_tool", None) or getattr(manager, "add_tool", None)
+    if callable(add_tool):
+        manager._linc_orig_add_tool = add_tool
+
+        @functools.wraps(add_tool)
+        def _strict_add_tool(*args: Any, **kwargs: Any) -> Any:
+            tool = add_tool(*args, **kwargs)
+            _harden_tool(tool, strict_types=strict_types)
+            return tool
+
+        manager.add_tool = _strict_add_tool
+    return server
+
+
+@contextlib.contextmanager
+def stubbed_tool_fn(server: Any, name: str) -> Iterator[None]:
+    """Temporarily replace a registered tool's callable with a no-op for validation probes."""
+    _, list_tools = _tool_manager(server, "stubbed_tool_fn")
+    for tool in list_tools():
+        if getattr(tool, "name", None) == name:
+            orig = tool.fn
+
+            async def _async_noop(**_: Any) -> dict[str, bool]:
+                return {"ok": True}
+
+            def _sync_noop(**_: Any) -> dict[str, bool]:
+                return {"ok": True}
+
+            tool.fn = _async_noop if getattr(tool, "is_async", False) else _sync_noop
+            try:
+                yield
+            finally:
+                tool.fn = orig
+            return
+    yield
+
+
+def registry_of(server: Any) -> list[ToolSpec]:
+    """Return every tool registered on a FastMCP server as a ToolSpec."""
+    _, list_tools = _tool_manager(server, "registry_of")
+    specs: list[ToolSpec] = []
+    for tool in list_tools():
+        for attr in ("name", "fn", "parameters", "is_async"):
+            if not hasattr(tool, attr):
+                raise TypeError(
+                    f"FastMCP Tool lacks '{attr}' — SDK shape changed; update registry.py"
+                )
+        specs.append(
+            ToolSpec(
+                name=tool.name,
+                description=(tool.description or "").strip(),
+                parameters=dict(tool.parameters or {}),
+                fn=tool.fn,
+                is_async=bool(tool.is_async),
+            )
+        )
+    return specs
+

{linc_cli_kit-0.1.3 → linc_cli_kit-0.1.4}/src/linc_cli_kit/testing.py

@@ -1,6 +1,6 @@
 """Importable conformance suite (spec §5.5). Each repo calls assert_cli_parity in one test.
 
-Nine checks, run per mounted tool (unless justified-skipped):
+Ten checks, run per mounted tool (unless justified-skipped):
   1. coverage + justified skips
   2. --help exits 0 and names every required option
   3. stubbed success -> bare JSON on stdout, no ANSI, empty stderr, AND the payload the
@@ -22,6 +22,9 @@ Nine checks, run per mounted tool (unless justified-skipped):
      CliRunner alone cannot see it
   8. stubbed generic error -> exit 1, empty stdout, envelope on stderr
   9. `schema --json` lists every mounted command
+  10. unknown-argument rejection parity: MCP rejects an unknown argument (`ToolError` naming
+      the key + `additionalProperties: false` in the schema, via `strict_tools(server)`) the
+      same way the CLI rejects an unknown option (exit 2 + error envelope on stderr)
 
 Every JSON parse goes through a named assertion that reports the tool and the stream.
 
@@ -52,11 +55,13 @@ from dataclasses import dataclass, field
 from typing import Any
 from unittest.mock import patch
 
+import anyio
 import click
 from click.testing import CliRunner
+from mcp.server.fastmcp.exceptions import ToolError as FastMCPToolError
 
 from linc_cli_kit.output import to_json
-from linc_cli_kit.registry import ToolSpec, registry_of
+from linc_cli_kit.registry import ToolSpec, registry_of, stubbed_tool_fn
 from linc_cli_kit.schema import RESERVED, cli_name
 from linc_cli_kit.transport import LocalTransport
 
@@ -262,6 +267,47 @@ def _check_option_parity(cmd: click.Command, spec: ToolSpec) -> None:
             )
 
 
+def _check_unknown_argument_rejected(
+    cli: click.Group,
+    cmd: click.Command,
+    server: Any,
+    spec: ToolSpec,
+    name: str,
+    sample: dict[str, Any],
+) -> None:
+    # 10. unknown-argument rejection parity: Click rejects an unknown option with exit 2 and an
+    # error envelope on stderr; MCP must reject an unknown argument the same way (via
+    # strict_tools(server)) rather than silently dropping it.
+    unknown_key = "__linc_unknown_arg__"
+    unknown_flag = "--__linc_unknown_arg__"
+    r = _invoke(cli, [name, *_sample_args(cmd, sample), unknown_flag, "x"])
+    assert r.exit_code == 2, (
+        f"{spec.name}: expected exit 2 for unknown CLI option {unknown_flag}, "
+        f"got {r.exit_code}: {r.output}"
+    )
+    assert r.stdout == "", f"{spec.name}: stdout not empty on unknown CLI option"
+    doc = _loads(r.stderr, spec.name, "stderr")
+    assert isinstance(doc, dict) and doc.get("error"), (
+        f"{spec.name}: no envelope on stderr for unknown CLI option; got {r.stderr[:200]!r}"
+    )
+
+    with stubbed_tool_fn(server, spec.name):
+        try:
+            anyio.run(server.call_tool, spec.name, {**sample, unknown_key: "x"})
+        except FastMCPToolError as exc:
+            assert unknown_key in str(exc), (
+                f"{spec.name}: MCP error for unknown argument did not name {unknown_key!r}: {exc}"
+            )
+        else:
+            raise AssertionError(
+                f"{spec.name}: MCP accepted unknown argument {unknown_key!r} while CLI "
+                "rejected it — call strict_tools(server)"
+            )
+    assert spec.parameters.get("additionalProperties") is False, (
+        f"{spec.name}: MCP schema missing additionalProperties: false — call strict_tools(server)"
+    )
+
+
 def _assert_error_stubs(
     cli: click.Group, transport_holder: Any, name: str, args: list[str], label: str
 ) -> None:
@@ -440,7 +486,9 @@ def _run_parity(
 
         _check_option_parity(cmd, spec)
         sample = samples.get(spec.name)
-        _check_stubbed_output_contract(cli, cmd, spec, name, sample or _minimal_sample(spec))
+        sample_or_minimal = sample or _minimal_sample(spec)
+        _check_stubbed_output_contract(cli, cmd, spec, name, sample_or_minimal)
+        _check_unknown_argument_rejected(cli, cmd, server, spec, name, sample_or_minimal)
         if sample is not None:
             _check_execution_consistency(cli, cmd, spec, name, sample)
 

{linc_cli_kit-0.1.3 → linc_cli_kit-0.1.4}/tests/conftest.py

@@ -8,6 +8,8 @@ import click
 import pytest
 from mcp.server.fastmcp import FastMCP
 
+from linc_cli_kit import strict_tools
+
 
 def build_toy_server() -> FastMCP:
     server = FastMCP("toy")
@@ -46,7 +48,7 @@ def build_toy_server() -> FastMCP:
         """Async tool."""
         return {"device": device, "async": True}
 
-    return server
+    return strict_tools(server)
 
 
 @pytest.fixture

{linc_cli_kit-0.1.3 → linc_cli_kit-0.1.4}/tests/test_json_encoding.py

@@ -141,7 +141,7 @@ def test_parity_execution_consistency_uses_the_same_encoder():
     import click
     from mcp.server.fastmcp import FastMCP
 
-    from linc_cli_kit import install_globals, mount_tools
+    from linc_cli_kit import install_globals, mount_tools, strict_tools
     from linc_cli_kit.testing import assert_cli_parity
     from linc_cli_kit.transport import LocalTransport
 
@@ -152,6 +152,8 @@ def test_parity_execution_consistency_uses_the_same_encoder():
         """When."""
         return {"device": device, "at": datetime.datetime(2026, 1, 1, 0, 0), "tags": {"x"}}
 
+    strict_tools(server)
+
     @click.group()
     def cli() -> None:
         """dt"""

linc_cli_kit-0.1.4/tests/test_registry.py

@@ -0,0 +1,128 @@
+import anyio
+import pytest
+from mcp.server.fastmcp import Context, FastMCP
+from mcp.server.fastmcp.exceptions import ToolError as FastMCPToolError
+
+from linc_cli_kit import strict_tools
+from linc_cli_kit.registry import ToolSpec, registry_of
+
+
+def test_registry_exposes_fn_schema_and_async_flag(toy_server):
+    specs = {s.name: s for s in registry_of(toy_server)}
+    assert set(specs) == {
+        "toy_echo", "toy_extras", "toy_tags", "toy_reserved", "toy_fail", "toy_async"
+    }
+    echo = specs["toy_echo"]
+    assert isinstance(echo, ToolSpec)
+    assert callable(echo.fn)
+    assert echo.parameters["required"] == ["device"]
+    assert echo.parameters["properties"]["count"] == {
+        "default": 1, "title": "Count", "type": "integer"
+    }
+    assert echo.description.startswith("Echo the inputs back")
+    assert specs["toy_async"].is_async is True
+    assert echo.is_async is False
+
+
+def test_registry_fails_loudly_on_unknown_server_shape():
+    class Bogus:  # no _tool_manager
+        pass
+
+    with pytest.raises(TypeError, match="FastMCP tool registry"):
+        registry_of(Bogus())
+
+
+def test_contract_strict_tools_rejects_unknown_key_that_fastmcp_ignores_by_default():
+    """[contract] #15: without strict_tools(server), FastMCP silently drops unknown keys;
+    with strict_tools(server), calling a tool with an unknown key raises ToolError naming it."""
+    server = FastMCP("strict_probe")
+
+    @server.tool()
+    def tap(x: int, y: int) -> dict:
+        return {"x": x, "y": y}
+
+    # Baseline without the hook: extra keys are silently ignored by FastMCP.
+    anyio.run(server.call_tool, "tap", {"x": 1, "y": 2, "hallucinated_flag": True})
+
+    returned = strict_tools(server)
+    assert returned is server
+
+    with pytest.raises(FastMCPToolError, match="hallucinated_flag"):
+        anyio.run(server.call_tool, "tap", {"x": 1, "y": 2, "hallucinated_flag": True})
+
+
+def test_contract_strict_tools_preserves_valid_calls_and_context_injection():
+    """[contract] #15: valid calls (including lax str->int coercion by default and FastMCP
+    Context injection) still succeed after strict_tools(server); strict_types=True is opt-in."""
+    server = FastMCP("ctx_probe")
+
+    @server.tool()
+    def inspect_device(device: str, count: int, ctx: Context) -> dict:
+        return {"device": device, "count": count, "has_ctx": isinstance(ctx, Context)}
+
+    strict_tools(server)
+
+    # Valid call + Context injection + default lax int coercion ("3" -> 3) still work.
+    blocks = anyio.run(server.call_tool, "inspect_device", {"device": "X", "count": "3"})
+    assert '"count": 3' in blocks[0].text
+    assert '"has_ctx": true' in blocks[0].text
+
+    # Opt-in strict_types=True rejects str->int coercion too.
+    strict_tools(server, strict_types=True)
+    with pytest.raises(FastMCPToolError, match="count"):
+        anyio.run(server.call_tool, "inspect_device", {"device": "X", "count": "3"})
+
+
+def test_contract_strict_tools_sets_additional_properties_false_on_list_tools(toy_server):
+    """[contract] #15: list_tools() reports additionalProperties: false for every tool."""
+    strict_tools(toy_server)
+    tools = anyio.run(toy_server.list_tools)
+    assert len(tools) == 6
+    for tool in tools:
+        assert tool.inputSchema.get("additionalProperties") is False, tool.name
+    for spec in registry_of(toy_server):
+        assert spec.parameters.get("additionalProperties") is False, spec.name
+
+
+def test_contract_strict_tools_fails_loudly_on_missing_sdk_internals():
+    """[contract] #15: fails loudly (TypeError naming the SDK change) if _tool_manager or
+    fn_metadata.arg_model is missing."""
+
+    class NoManager:
+        pass
+
+    with pytest.raises(TypeError, match="FastMCP tool registry"):
+        strict_tools(NoManager())
+
+    class NoParamsTool:
+        def __init__(self):
+            self.name = "no_params"
+            self.parameters = None
+            self.fn_metadata = None
+
+    class NoParamsManager:
+        def list_tools(self):
+            return [NoParamsTool()]
+
+    class NoParamsServer:
+        _tool_manager = NoParamsManager()
+
+    with pytest.raises(TypeError, match=r"parameters.*SDK shape changed"):
+        strict_tools(NoParamsServer())
+
+    class BrokenTool:
+        def __init__(self):
+            self.name = "broken"
+            self.parameters = {"type": "object"}
+            self.fn_metadata = None
+
+    class BrokenManager:
+        def list_tools(self):
+            return [BrokenTool()]
+
+    class BrokenServer:
+        _tool_manager = BrokenManager()
+
+    with pytest.raises(TypeError, match=r"fn_metadata\.arg_model.*SDK shape changed"):
+        strict_tools(BrokenServer())
+

{linc_cli_kit-0.1.3 → linc_cli_kit-0.1.4}/tests/test_testing.py

@@ -187,6 +187,8 @@ def _polluting_server(write):
     """A toy server whose only tool runs `write()` before returning its payload."""
     from mcp.server.fastmcp import FastMCP
 
+    from linc_cli_kit import strict_tools
+
     server = FastMCP("polluter")
 
     @server.tool()
@@ -195,7 +197,7 @@ def _polluting_server(write):
         write()
         return {"device": device}
 
-    return server
+    return strict_tools(server)
 
 
 def _parity_on(server):
@@ -302,3 +304,38 @@ def test_non_object_json_on_stderr_is_a_named_assertion(toy_server, toy_group):
     cmd.callback = list_errors
     with pytest.raises(AssertionError, match=r"toy_echo.*no envelope on stderr"):
         assert_cli_parity(cli, toy_server, prefix="toy_")
+
+
+def test_contract_assert_cli_parity_requires_mcp_to_reject_unknown_arguments():
+    """[contract] #15: assert_cli_parity checks that MCP rejects an unknown argument the same
+    way the CLI rejects an unknown option, and never invokes the real tool fn when unstrict."""
+    from mcp.server.fastmcp import FastMCP
+
+    from linc_cli_kit import strict_tools
+
+    server = FastMCP("lax")
+    side_effects: list[str] = []
+
+    @server.tool()
+    def lax_ping(device: str) -> dict:
+        """Ping a device."""
+        side_effects.append(device)
+        return {"device": device}
+
+    @click.group()
+    def cli() -> None:
+        """lax"""
+
+    install_globals(cli)
+    mount_tools(cli, server, prefix="lax_", transport=LocalTransport())
+
+    # Without strict_tools(server), MCP accepts unknown args while the CLI rejects them.
+    with pytest.raises(AssertionError, match=r"lax_ping.*unknown argument.*strict_tools"):
+        assert_cli_parity(cli, server, prefix="lax_")
+    assert side_effects == [], "unstrict probe must not execute the real tool body"
+
+    # Once strict_tools(server) is applied, parity passes.
+    strict_tools(server)
+    report = assert_cli_parity(cli, server, prefix="lax_")
+    assert report.tools == 1
+

linc_cli_kit-0.1.3/src/linc_cli_kit/registry.py

@@ -1,48 +0,0 @@
-"""The only module allowed to touch FastMCP's private tool manager.
-
-`_tool_manager` is private SDK API (renamed in the SDK's v2 line). Everything
-else in the kit consumes ToolSpec, so an SDK change is fixed in one place.
-"""
-
-from __future__ import annotations
-
-from collections.abc import Callable
-from dataclasses import dataclass
-from typing import Any
-
-
-@dataclass(frozen=True)
-class ToolSpec:
-    name: str
-    description: str
-    parameters: dict[str, Any]
-    fn: Callable[..., Any]
-    is_async: bool
-
-
-def registry_of(server: Any) -> list[ToolSpec]:
-    """Return every tool registered on a FastMCP server as a ToolSpec."""
-    manager = getattr(server, "_tool_manager", None)
-    list_tools = getattr(manager, "list_tools", None)
-    if manager is None or list_tools is None:
-        raise TypeError(
-            "registry_of() expects a FastMCP server with a FastMCP tool registry "
-            f"(_tool_manager.list_tools); got {type(server).__name__}"
-        )
-    specs: list[ToolSpec] = []
-    for tool in list_tools():
-        for attr in ("name", "fn", "parameters", "is_async"):
-            if not hasattr(tool, attr):
-                raise TypeError(
-                    f"FastMCP Tool lacks '{attr}' — SDK shape changed; update registry.py"
-                )
-        specs.append(
-            ToolSpec(
-                name=tool.name,
-                description=(tool.description or "").strip(),
-                parameters=dict(tool.parameters or {}),
-                fn=tool.fn,
-                is_async=bool(tool.is_async),
-            )
-        )
-    return specs

linc_cli_kit-0.1.3/tests/test_registry.py

@@ -1,28 +0,0 @@
-from linc_cli_kit.registry import ToolSpec, registry_of
-
-
-def test_registry_exposes_fn_schema_and_async_flag(toy_server):
-    specs = {s.name: s for s in registry_of(toy_server)}
-    assert set(specs) == {
-        "toy_echo", "toy_extras", "toy_tags", "toy_reserved", "toy_fail", "toy_async"
-    }
-    echo = specs["toy_echo"]
-    assert isinstance(echo, ToolSpec)
-    assert callable(echo.fn)
-    assert echo.parameters["required"] == ["device"]
-    assert echo.parameters["properties"]["count"] == {
-        "default": 1, "title": "Count", "type": "integer"
-    }
-    assert echo.description.startswith("Echo the inputs back")
-    assert specs["toy_async"].is_async is True
-    assert echo.is_async is False
-
-
-def test_registry_fails_loudly_on_unknown_server_shape():
-    class Bogus:  # no _tool_manager
-        pass
-
-    import pytest
-
-    with pytest.raises(TypeError, match="FastMCP tool registry"):
-        registry_of(Bogus())