pythonparts-mcp 0.2.0__py3-none-any.whl

server/tools/_sandbox_worker.py

@@ -0,0 +1,196 @@
+"""
+Self-contained worker script that executes arbitrary Python against the ALLPLAN
+libraries and returns the captured console output as JSON on stdout.
+
+This script is executed by the ALLPLAN-embedded interpreter (not the MCP server's
+interpreter). It must not import anything from the server package.
+
+Unlike the Vibe Coding Connector, this runs outside ALLPLAN: there is no document
+and no coordinate input, so only APIs that work without them return meaningful
+results.
+
+Protocol (persistent mode):
+  1. Caller writes one JSON init line to stdin:
+         {"sys_path": [...], "prg_plugins": "...", "allplan_paths_mock": "...", "etc_pythonparts": "..."}
+     Worker sets up the ALLPLAN runtime and imports the interface modules, then
+     writes one JSON ack to stdout:
+         {"ok": true, "data": {"available": [...], "unavailable": {...}}}
+         or {"ok": false, "error": "..."}
+  2. For each snippet the caller writes one JSON line:
+         {"code": "print(1 + 1)"}
+     Worker writes one JSON result to stdout, then loops.
+  3. Caller closes stdin (EOF) to signal shutdown; the worker exits cleanly.
+"""
+
+# Running untrusted code and surviving anything it throws is this module's purpose.
+# pylint: disable=broad-except,exec-used,global-statement,import-error
+
+from __future__ import annotations
+
+import importlib
+import importlib.util
+import io
+import json
+import os
+import sys
+import traceback
+from contextlib import redirect_stderr, redirect_stdout
+from typing import Any
+
+_DLL_DIR_HANDLE: Any | None = None
+
+# Alias -> module name, mirroring the globals of the Vibe Coding Connector's /execute
+# route so a snippet can be moved between the two tools unchanged.
+_MODULE_ALIASES = {
+    "AllplanSettings": "NemAll_Python_AllplanSettings",
+    "AllplanArchElements": "NemAll_Python_ArchElements",
+    "AllplanBaseElements": "NemAll_Python_BaseElements",
+    "AllplanBasisElements": "NemAll_Python_BasisElements",
+    "AllplanGeometry": "NemAll_Python_Geometry",
+    "AllplanElementAdapter": "NemAll_Python_IFW_ElementAdapter",
+    "AllplanIFWInput": "NemAll_Python_IFW_Input",
+    "AllplanPalette": "NemAll_Python_Palette",
+    "AllplanReinforcement": "NemAll_Python_Reinforcement",
+    "AllplanPrecast": "NemAll_Python_Precast",
+    "AllplanUtility": "NemAll_Python_Utility",
+}
+
+_modules: dict[str, Any] = {}
+_unavailable: dict[str, str] = {}
+
+# A runaway snippet such as `while True: print(...)` would otherwise grow the
+# capture buffer until the machine runs out of memory, long before the caller's
+# timeout kills the worker.
+_MAX_OUTPUT_CHARS = 1_000_000
+
+
+class _BoundedOutput(io.TextIOBase):
+    """Text sink that keeps at most `limit` characters and discards the rest."""
+
+    def __init__(self, limit: int = _MAX_OUTPUT_CHARS) -> None:
+        super().__init__()
+        self._limit = limit
+        self._chunks: list[str] = []
+        self._size = 0
+        self._truncated = False
+
+    def writable(self) -> bool:
+        return True
+
+    def write(self, text: str) -> int:
+        if self._truncated:
+            return len(text)
+        remaining = self._limit - self._size
+        if len(text) <= remaining:
+            self._chunks.append(text)
+            self._size += len(text)
+        else:
+            self._chunks.append(text[:remaining])
+            self._chunks.append(
+                f"\n... output truncated after {self._limit} characters ...\n"
+            )
+            self._size = self._limit
+            self._truncated = True
+        return len(text)
+
+    def getvalue(self) -> str:
+        return "".join(self._chunks)
+
+
+def _read_line() -> dict | None:
+    """Return the next JSON object from stdin, or None on EOF."""
+    line = sys.stdin.readline()
+    if not line:
+        return None
+    return json.loads(line)
+
+
+def _setup_environment(params: dict) -> None:
+    """Inject DLL search path and sys.path, then patch AllplanPaths if possible."""
+    global _DLL_DIR_HANDLE
+
+    _DLL_DIR_HANDLE = os.add_dll_directory(params["prg_plugins"])
+
+    for path in reversed(params["sys_path"]):
+        if path not in sys.path:
+            sys.path.insert(0, path)
+
+    # Patch AllplanSettings.AllplanPaths so framework modules that call
+    # GetPathOfApplication() at import-time receive the real Prg path rather
+    # than the interpreter directory (Prg\Python\).
+    try:
+        mock_spec = importlib.util.spec_from_file_location(
+            "AllplanPathsMock", params["allplan_paths_mock"]
+        )
+        if mock_spec is None or mock_spec.loader is None:
+            raise ImportError("Could not load AllplanPathsMock spec")
+        mock_mod = importlib.util.module_from_spec(mock_spec)
+        mock_spec.loader.exec_module(mock_mod)
+
+        import NemAll_Python_AllplanSettings as _AllplanSettings  # noqa: PLC0415
+        _AllplanSettings.AllplanPaths = mock_mod.AllplanPathsMock(
+            etc_path=params["etc_pythonparts"]
+        )
+    except Exception:  # noqa: BLE001 — AllplanPaths mock is optional; real errors surface below
+        pass
+
+
+def _import_modules() -> None:
+    """Import every interface module once, recording the ones that refuse to load.
+
+    Some modules need a running ALLPLAN and cannot be imported standalone; that is
+    expected, so one failure must not take down the whole sandbox.
+    """
+    for alias, module_name in _MODULE_ALIASES.items():
+        try:
+            _modules[alias] = importlib.import_module(module_name)
+        except Exception as exc:  # noqa: BLE001 — report, don't abort
+            _unavailable[alias] = f"{type(exc).__name__}: {exc}"
+
+
+def _execute(code: str) -> dict:
+    """Run one snippet with a fresh globals dict and return its captured output."""
+    output = _BoundedOutput()
+    try:
+        with redirect_stdout(output), redirect_stderr(output):
+            exec(code, dict(_modules))  # noqa: S102 — executing user code is the point
+    except BaseException:  # noqa: BLE001 — SystemExit from the snippet must not kill the worker
+        return {"ok": False, "error": output.getvalue() + traceback.format_exc()}
+    return {"ok": True, "data": {"output": output.getvalue()}}
+
+
+def _emit(obj: dict) -> None:
+    """Write one JSON line to the real stdout and flush immediately."""
+    sys.stdout.write(json.dumps(obj) + "\n")
+    sys.stdout.flush()
+
+
+def main() -> None:
+    # Stage 1: one-time environment setup and module import.
+    init_params = _read_line()
+    if init_params is None:
+        return
+    try:
+        _setup_environment(init_params)
+        _import_modules()
+        _emit({
+            "ok": True,
+            "data": {"available": sorted(_modules), "unavailable": _unavailable},
+        })
+    except Exception as exc:  # noqa: BLE001
+        _emit({"ok": False, "error": f"{type(exc).__name__}: {exc}"})
+        return
+
+    # Stage 2: execution loop — one snippet per line until stdin closes.
+    while True:
+        query = _read_line()
+        if query is None:
+            break
+        try:
+            _emit(_execute(query["code"]))
+        except Exception as exc:  # noqa: BLE001
+            _emit({"ok": False, "error": f"{type(exc).__name__}: {exc}"})
+
+
+if __name__ == "__main__":
+    main()

server/tools/connector.py

@@ -0,0 +1,81 @@
+"""
+Shared helper for tools that require the Vibe Coding Connector to be running in ALLPLAN.
+
+Apply the `@requires_allplan_connector` decorator to any `@mcp.tool` function that talks to the
+connector's HTTP server; it takes care of the health check, the "please start it" elicitation, and
+returning "Tool not available" once the user declines.
+"""
+
+from __future__ import annotations
+
+import functools
+import inspect
+import urllib.error
+import urllib.request
+from typing import Any, Callable, Coroutine, TypeVar
+
+from fastmcp import Context
+
+from ..config import CONNECTOR_BASE_URL
+
+_F = TypeVar("_F", bound=Callable[..., Coroutine[Any, Any, dict]])
+
+_HEALTH_TIMEOUT_SECONDS = 5.0
+
+_START_OPTION = "I started the connector"
+_DECLINE_OPTION = "I don't want to use the connector"
+_MAX_ELICIT_ROUNDS = 5
+
+# Set once the user declines; stays set for the life of this process (reset on server restart).
+_connector_declined = False
+
+
+def check_health(timeout: float = _HEALTH_TIMEOUT_SECONDS) -> bool:
+    """Return True if the Vibe Coding Connector responds to GET /health."""
+    try:
+        with urllib.request.urlopen(f"{CONNECTOR_BASE_URL}/health", timeout=timeout) as response:
+            return response.status == 200
+    except (urllib.error.URLError, TimeoutError):
+        return False
+
+
+async def ensure_connector_available(ctx: Context) -> bool:
+    """Return True once the connector answers /health, prompting the user to start it if needed."""
+    global _connector_declined
+
+    if _connector_declined:
+        return False
+
+    for _ in range(_MAX_ELICIT_ROUNDS):
+        if check_health():
+            return True
+
+        try:
+            result = await ctx.elicit(
+                "ALLPLAN is not reachable. Please start the Vibe Coding Connector in ALLPLAN.",
+                response_type=[_START_OPTION, _DECLINE_OPTION],
+            )
+        except Exception:  # noqa: BLE001 — client may not support elicitation
+            _connector_declined = True
+            return False
+
+        if result.action != "accept" or result.data == _DECLINE_OPTION:
+            _connector_declined = True
+            return False
+        # Otherwise the user picked _START_OPTION: loop around and re-check health.
+
+    return False
+
+
+def requires_allplan_connector(func: _F) -> _F:
+    """Gate a tool on the Vibe Coding Connector being available. The tool must take a `ctx: Context` parameter."""
+    signature = inspect.signature(func)
+
+    @functools.wraps(func)
+    async def wrapper(*args: Any, **kwargs: Any) -> dict:
+        ctx = signature.bind_partial(*args, **kwargs).arguments["ctx"]
+        if not await ensure_connector_available(ctx):
+            return {"ok": False, "error": "Tool not available"}
+        return await func(*args, **kwargs)
+
+    return wrapper  # type: ignore[return-value]

server/tools/inspect_symbol.py

@@ -0,0 +1,75 @@
+"""
+Tool: inspect_symbol
+
+Inspects a Python symbol in the ALLPLAN runtime using live introspection.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from fastmcp import FastMCP
+
+from ..config import AllplanConfig
+from ..paths import build_sys_path
+from ..worker import PersistentWorker
+from . import READ_ONLY_TOOL_ANNOTATIONS
+
+_INIT_TIMEOUT_SECONDS = 120.0
+_REQUEST_TIMEOUT_SECONDS = 30.0
+
+
+def _init_params(cfg: AllplanConfig) -> dict:
+    return {
+        "sys_path": build_sys_path(cfg),
+        "prg_plugins": str(cfg.prg / "plugins"),
+        "allplan_paths_mock": str(
+            cfg.etc / "PythonPartsFramework" / "TestHelper" / "Mock" / "AllplanPathsMock.py"
+        ),
+        "etc_pythonparts": str(cfg.etc / "PythonPartsFramework") + "\\",
+        "stub_dirs": [str(cfg.etc / "PythonPartsFramework" / "InterfaceStubs")],
+    }
+
+
+_worker = PersistentWorker(
+    Path(__file__).parent / "_introspect_worker.py",
+    _init_params,
+    init_timeout=_INIT_TIMEOUT_SECONDS,
+    request_timeout=_REQUEST_TIMEOUT_SECONDS,
+)
+
+
+def register_inspect_symbol_tools(mcp: FastMCP) -> None:
+    """Register all symbol-inspection tools on the given FastMCP instance."""
+
+    @mcp.tool(annotations=READ_ONLY_TOOL_ANNOTATIONS)
+    def inspect_symbol(symbol: str) -> dict:
+        """
+        Inspect a Python symbol in the ALLPLAN runtime using live introspection.
+
+        Returns the category, signature, docstring, and public members of the symbol.
+        Use this to verify that a symbol exists and to discover its API before
+        writing code against it.
+
+        For native (pybind11) modules the result is enriched from the matching
+        ``.pyi`` stub, which yields real signatures, per-overload documentation
+        and member signatures that live introspection cannot provide.
+
+        Args:
+            symbol: Dotted Python path to inspect.
+                    Examples:
+                        "NemAll_Python_Geometry.Point3D"   — a class
+                        "AllplanBasisElements"              — a module
+                        "NemAll_Python_Geometry.Point3D.X" — a member
+
+        Returns a dict with:
+            ok      — True on success, False on failure
+            data    — {symbol, category, module, docstring, signature, overloads,
+                       members, magic_methods, stub_file}
+                      docstrings are returned as a list of lines (split on \n);
+                      overloads is a list of {signature, docstring} and is empty
+                      for non-overloaded symbols; members carry signatures when
+                      they come from a stub
+            error   — present only when ok is False
+        """
+        return _worker.request({"symbol": symbol})

server/tools/run_snippet_in_allplan.py

@@ -0,0 +1,85 @@
+"""
+Tool: run_snippet_in_allplan
+
+Executes a Python code snippet inside ALLPLAN's own embedded interpreter via
+the Vibe Coding Connector PythonPart's HTTP server, and returns its stdout.
+"""
+
+from __future__ import annotations
+
+import urllib.error
+import urllib.request
+
+from fastmcp import Context, FastMCP
+
+from ..config import CONNECTOR_BASE_URL
+from . import MUTATING_TOOL_ANNOTATIONS
+from .connector import requires_allplan_connector
+
+_EXECUTE_TIMEOUT_SECONDS = 60.0
+
+
+def _call_execute(code: str, timeout: float) -> tuple[int, str]:
+    """POST the snippet to /execute and return (status_code, response_body)."""
+    request = urllib.request.Request(
+        f"{CONNECTOR_BASE_URL}/execute",
+        data=code.encode("utf-8"),
+        method="POST",
+        headers={"Content-Type": "text/plain; charset=utf-8"},
+    )
+    try:
+        with urllib.request.urlopen(request, timeout=timeout) as response:
+            return response.status, response.read().decode("utf-8", errors="replace")
+    except urllib.error.HTTPError as exc:
+        # The connector returns 500 with the captured output + traceback in the body.
+        return exc.code, exc.read().decode("utf-8", errors="replace")
+
+
+def register_run_snippet_in_allplan_tools(mcp: FastMCP) -> None:
+    @mcp.tool(annotations=MUTATING_TOOL_ANNOTATIONS)
+    @requires_allplan_connector
+    async def run_snippet_in_allplan(code: str, ctx: Context) -> dict:
+        """
+        Run a Python code snippet inside ALLPLAN's embedded interpreter and
+        return its stdout.
+
+        This runs in the user's live ALLPLAN session, so the snippet can read and
+        modify the open drawing and project data. Use it only when the snippet
+        genuinely needs `document`, `coord_input`, the project, or user settings.
+        For everything else — geometry math, checking an API's behaviour or a
+        return type — use `run_snippet_in_sandbox`, which is isolated from the
+        user's data.
+
+        Requires the Vibe Coding Connector PythonPart to be running in ALLPLAN.
+        If it isn't reachable, the user is prompted to start it; declining
+        makes this tool return "Tool not available" for the rest of the
+        session, until the MCP server is restarted.
+
+        The snippet executes with the following already available as globals
+        (no need to import them):
+            AllplanSettints, AllplanArchElements, AllplanBaseElements,
+            AllplanBasisElements, AllplanGeometry, AllplanElementAdapter,
+            AllplanIFWInput, AllplanPalette, AllplanReinforcement,
+            AllplanPrecast, AllplanUtility — pre-imported ALLPLAN modules
+            document     — the active DocumentAdapter
+            coord_input  — the active CoordinateInput
+
+        Only `print()` output is returned; the snippet's return value is ignored.
+
+        Args:
+            code: Python source code to execute, as plain text.
+
+        Returns a dict with:
+            ok      — True on success, False on failure
+            data    — {"output": str} on success
+            error   — present only when ok is False ("Tool not available",
+                      or the snippet's traceback if it raised)
+        """
+        try:
+            status_code, body = _call_execute(code, _EXECUTE_TIMEOUT_SECONDS)
+        except (urllib.error.URLError, TimeoutError) as exc:
+            return {"ok": False, "error": f"Failed to reach the Vibe Coding Connector: {exc}"}
+
+        if status_code == 200:
+            return {"ok": True, "data": {"output": body}}
+        return {"ok": False, "error": body}

server/tools/run_snippet_in_sandbox.py

@@ -0,0 +1,91 @@
+"""
+Tool: run_snippet_in_sandbox
+
+Executes a Python code snippet against the ALLPLAN libraries in a separate,
+document-less process, so nothing can touch the user's live ALLPLAN session.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from fastmcp import FastMCP
+
+from ..config import AllplanConfig
+from ..paths import build_sys_path
+from ..worker import PersistentWorker
+from . import MUTATING_TOOL_ANNOTATIONS
+
+# The first call pays for loading the ALLPLAN DLLs; later calls reuse the process.
+_INIT_TIMEOUT_SECONDS = 120.0
+_REQUEST_TIMEOUT_SECONDS = 60.0
+
+
+def _init_params(cfg: AllplanConfig) -> dict:
+    return {
+        "sys_path": build_sys_path(cfg),
+        "prg_plugins": str(cfg.prg / "plugins"),
+        "allplan_paths_mock": str(
+            cfg.etc / "PythonPartsFramework" / "TestHelper" / "Mock" / "AllplanPathsMock.py"
+        ),
+        "etc_pythonparts": str(cfg.etc / "PythonPartsFramework") + "\\",
+    }
+
+
+_worker = PersistentWorker(
+    Path(__file__).parent / "_sandbox_worker.py",
+    _init_params,
+    init_timeout=_INIT_TIMEOUT_SECONDS,
+    request_timeout=_REQUEST_TIMEOUT_SECONDS,
+)
+
+
+def register_run_snippet_in_sandbox_tools(mcp: FastMCP) -> None:
+    @mcp.tool(annotations=MUTATING_TOOL_ANNOTATIONS)
+    def run_snippet_in_sandbox(code: str) -> dict:
+        """
+        Run a Python code snippet against the ALLPLAN libraries in a separate,
+        isolated process and return its stdout. It cannot touch the user's
+        drawing or project data, and ALLPLAN does not need to be running.
+
+        Use it to verify geometry math and API behaviour, for example to check a
+        `NemAll_Python_Geometry` result or a class signature, before writing a
+        full PythonPart.
+
+        There is no document and no coordinate input, so `document` and
+        `coord_input` are NOT available here. Any call that needs the open
+        drawing, the project, or user settings will fail or return a
+        meaningless value.
+
+        The snippet must not call anything that shows a user interface, such as
+        `AllplanUtility.ShowMessageBox` or a file dialog. There is no ALLPLAN
+        window to host it, so the call never returns and the snippet is lost to
+        the timeout.
+
+        The snippet executes with the following already available as globals
+        (no need to import them):
+            AllplanSettints, AllplanArchElements, AllplanBaseElements,
+            AllplanBasisElements, AllplanGeometry, AllplanElementAdapter,
+            AllplanIFWInput, AllplanPalette, AllplanReinforcement,
+            AllplanPrecast, AllplanUtility — pre-imported ALLPLAN modules
+
+        Only `print()` output is returned; the snippet's return value is ignored.
+        Globals do not persist between calls, so each snippet must be
+        self-contained. The snippet must terminate — it is abandoned after
+        60 seconds.
+
+        Args:
+            code: Python source code to execute, as plain text.
+
+        Returns a dict with:
+            ok      — True on success, False on failure
+            data    — {"output": str} on success
+            error   — present only when ok is False (the snippet's traceback,
+                      or the reason the sandbox could not be started)
+        """
+        result = _worker.request({"code": code})
+
+        unavailable = _worker.init_data.get("unavailable")
+        if unavailable and result.get("ok"):
+            result["data"]["unavailable_modules"] = unavailable
+        return result

server/tools/runtime_context.py

@@ -0,0 +1,157 @@
+"""
+Tools: get_allplan_info, get_python_env_info, list_site_packages
+
+Focused tools that expose ALLPLAN application info, the embedded Python
+environment, and installed site-packages as three separate concerns.
+"""
+
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+
+from fastmcp import FastMCP
+
+from ..config import AllplanConfig, get_config
+from ..paths import build_sys_path, interpreter_path, framework_version
+from . import READ_ONLY_TOOL_ANNOTATIONS
+
+
+def _python_version(interpreter_exe: str) -> str:
+    """Run ``python --version`` and return the version string, e.g. ``'3.11.9'``."""
+    result = subprocess.run(
+        [interpreter_exe, "--version"],
+        capture_output=True,
+        text=True,
+    )
+    # Output is either on stdout or stderr depending on Python version
+    raw = (result.stdout or result.stderr).strip()
+    # "Python 3.11.9" → "3.11.9"
+    return raw.removeprefix("Python ").strip()
+
+
+def _read_metadata_field(metadata_file: Path, field: str) -> str:
+    """Return the value of a RFC-822 metadata field, or empty string if absent."""
+    prefix = f"{field}: "
+    for line in metadata_file.read_text(encoding="utf-8", errors="replace").splitlines():
+        if line.startswith(prefix):
+            return line[len(prefix):].strip()
+    return ""
+
+
+def _scan_installed_packages(cfg: AllplanConfig) -> list[dict]:
+    """Scan ``*site-packages*`` directories in the ALLPLAN sys.path for installed packages.
+
+    Only packages with a ``.dist-info/METADATA`` file are reported. Deduplication
+    keeps the first occurrence, matching Python's own import resolution order.
+
+    Args:
+        cfg: Active ALLPLAN configuration.
+
+    Returns:
+        Sorted list of ``{"name": str, "version": str | None}`` dicts.
+    """
+    packages: list[dict] = []
+    seen: set[str] = set()
+
+    site_dirs = [
+        Path(p) for p in build_sys_path(cfg)
+        if "site-packages" in p
+    ]
+
+    for site_dir in site_dirs:
+        if not site_dir.is_dir():
+            continue
+        for dist_info in site_dir.glob("*.dist-info"):
+            metadata = dist_info / "METADATA"
+            if not metadata.is_file():
+                continue
+            name = _read_metadata_field(metadata, "Name")
+            if not name:
+                continue
+            key = name.lower()
+            if key not in seen:
+                seen.add(key)
+                version = _read_metadata_field(metadata, "Version")
+                packages.append({"name": name, "version": version or None})
+
+    return sorted(packages, key=lambda p: p["name"].lower())
+
+
+def register_runtime_context_tools(mcp: FastMCP) -> None:
+    """Register all runtime-context tools on the given FastMCP instance."""
+
+    @mcp.tool(annotations=READ_ONLY_TOOL_ANNOTATIONS)
+    def get_allplan_info() -> dict:
+        """
+        Get the installed ALLPLAN version and its file-system paths.
+
+        Returns:
+            version:  The ALLPLAN (and PythonParts framework) version string.
+            paths:    The four ALLPLAN installation paths:
+                        prg - containing program binaries including the embedded Python interpreter,
+                        etc - shared configuration and resources,
+                        std - office-scoped resources,
+                        usr - user-scoped resources.
+        """
+        try:
+            cfg = get_config()
+            version = framework_version(cfg)
+        except Exception as exc:  # noqa: BLE001
+            return {"ok": False, "error": str(exc)}
+
+        return {
+            "ok": True,
+            "data": {
+                "version": version,
+
+                "paths": {
+                    "prg": str(cfg.prg),
+                    "etc": str(cfg.etc),
+                    "std": str(cfg.std),
+                    "usr": str(cfg.usr),
+                },
+            },
+        }
+
+    @mcp.tool(annotations=READ_ONLY_TOOL_ANNOTATIONS)
+    def get_python_env_info() -> dict:
+        """
+        Get info about the Python environment embedded inside ALLPLAN.
+
+        This is the interpreter and sys.path that ALLPLAN uses when executing
+        PythonParts scripts at runtime.
+
+        Returns:
+            interpreter_path:  Absolute path to the ALLPLAN-embedded python.exe.
+            python_version:    Version string of that interpreter (e.g. '3.11.9').
+            sys_path:          Ordered list of directories ALLPLAN adds to sys.path.
+        """
+        cfg = get_config()
+        exe = str(interpreter_path(cfg.prg))
+
+        return {
+            "ok": True,
+            "data": {
+                "interpreter_path": exe,
+                "python_version": _python_version(exe),
+                "sys_path": build_sys_path(cfg),
+            },
+        }
+
+    @mcp.tool(annotations=READ_ONLY_TOOL_ANNOTATIONS)
+    def list_site_packages() -> dict:
+        """
+        List all Python packages installed in the ALLPLAN-embedded python environment.
+
+        Returns:
+            Deduplicated (first occurrence wins, matching Python's import order) list
+            of installed packages sorted alphabetically by package name. Each package represented as a dict
+            like ``{"name": str, "version": str | null}``
+        """
+        cfg = get_config()
+
+        return {
+            "ok": True,
+            "data": _scan_installed_packages(cfg),
+        }