mcp-stata 1.6.2__py3-none-any.whl → 1.6.8__py3-none-any.whl

mcp_stata/discovery.py

@@ -1,22 +1,32 @@
 import os
+import sys
 import platform
 import glob
 import logging
 import shutil
+import ntpath
 
-from typing import Tuple, List
+from typing import Tuple, List, Optional
 
 logger = logging.getLogger("mcp_stata.discovery")
 
 
-def _normalize_env_path(raw: str) -> str:
-    """Strip quotes/whitespace and expand variables for STATA_PATH."""
+def _normalize_env_path(raw: str, system: str) -> str:
+    """Strip quotes/whitespace, expand variables, and normalize slashes for STATA_PATH."""
     cleaned = raw.strip()
-    if (cleaned.startswith("\"") and cleaned.endswith("\"")) or (
+    if (cleaned.startswith('"') and cleaned.endswith('"')) or (
         cleaned.startswith("'") and cleaned.endswith("'")
     ):
         cleaned = cleaned[1:-1].strip()
-    return os.path.expandvars(os.path.expanduser(cleaned))
+
+    expanded = os.path.expandvars(os.path.expanduser(cleaned))
+
+    # Always normalize path separators for the intended platform. This is especially
+    # important when running Windows discovery tests on non-Windows hosts where
+    # os.path (PosixPath) would otherwise leave backslashes untouched.
+    if system == "Windows":
+        return ntpath.normpath(expanded)
+    return os.path.normpath(expanded)
 
 
 def _is_executable(path: str, system: str) -> bool:
@@ -24,7 +34,7 @@ def _is_executable(path: str, system: str) -> bool:
         return False
     if system == "Windows":
         # On Windows, check if it's a file and has .exe extension
-        return os.path.isfile(path) and path.lower().endswith('.exe')
+        return os.path.isfile(path) and path.lower().endswith(".exe")
     return os.access(path, os.X_OK)
 
 
@@ -39,12 +49,59 @@ def _dedupe_preserve(items: List[tuple]) -> List[tuple]:
     return unique
 
 
+def _dedupe_str_preserve(items: List[str]) -> List[str]:
+    seen = set()
+    out: List[str] = []
+    for s in items:
+        if not s:
+            continue
+        if s in seen:
+            continue
+        seen.add(s)
+        out.append(s)
+    return out
+
+
+def _resolve_windows_host_path(path: str, system: str) -> str:
+    """
+    On non-Windows hosts running Windows-discovery code, a Windows-style path
+    (with backslashes) won't match the real filesystem layout. If the normalized
+    path does not exist and we're emulating Windows, try swapping backslashes for
+    the host separator so tests can interact with the temp filesystem.
+    """
+    if system != "Windows":
+        return path
+    if os.path.exists(path):
+        return path
+    if os.sep != "\\" and "\\" in path:
+        alt_path = path.replace("\\", os.sep)
+        if os.path.exists(alt_path):
+            return alt_path
+    return path
+
+
+def _detect_system() -> str:
+    """
+    Prefer Windows detection via os.name / sys.platform instead of platform.system()
+    because some environments (e.g., Cygwin/MSYS) do not return "Windows".
+    """
+    if os.name == "nt" or sys.platform.startswith(("cygwin", "msys")):
+        return "Windows"
+    return platform.system()
+
+
 def find_stata_path() -> Tuple[str, str]:
     """
     Attempts to automatically locate the Stata installation path.
     Returns (path_to_executable, edition_string).
+
+    Behavior:
+    - If STATA_PATH is set and valid, use it.
+    - If STATA_PATH is set but invalid, fall back to auto-discovery.
+    - If auto-discovery fails, raise an error (including STATA_PATH failure context, if any).
     """
-    system = platform.system()
+    system = _detect_system()
+    stata_path_error: Optional[Exception] = None
 
     windows_binaries = [
         ("StataMP-64.exe", "mp"),
@@ -67,63 +124,80 @@ def find_stata_path() -> Tuple[str, str]:
     ]
 
     # 1. Check Environment Variable (supports quoted values and directory targets)
-    if os.environ.get("STATA_PATH"):
-        raw_path = os.environ["STATA_PATH"]
-        path = _normalize_env_path(raw_path)
-        logger.info("Using STATA_PATH override (normalized): %s", path)
-
-        # If a directory is provided, try standard binaries for the platform
-        if os.path.isdir(path):
-            search_set = []
-            if system == "Windows":
-                search_set = windows_binaries
-            elif system == "Linux":
-                search_set = linux_binaries
-            elif system == "Darwin":
-                search_set = [
-                    ("Contents/MacOS/stata-mp", "mp"),
-                    ("Contents/MacOS/stata-se", "se"),
-                    ("Contents/MacOS/stata", "be"),
-                    ("stata-mp", "mp"),
-                    ("stata-se", "se"),
-                    ("stata", "be"),
-                ]
-
-            for binary, edition in search_set:
-                candidate = os.path.join(path, binary)
-                if _is_executable(candidate, system):
-                    logger.info("Found Stata via STATA_PATH directory: %s (%s)", candidate, edition)
-                    return candidate, edition
+    raw_env_path = os.environ.get("STATA_PATH")
+    if raw_env_path:
+        try:
+            path = _normalize_env_path(raw_env_path, system)
+            path = _resolve_windows_host_path(path, system)
+            logger.info("Trying STATA_PATH override (normalized): %s", path)
+
+            # If a directory is provided, try standard binaries for the platform
+            if os.path.isdir(path):
+                search_set = []
+                if system == "Windows":
+                    search_set = windows_binaries
+                elif system == "Linux":
+                    search_set = linux_binaries
+                elif system == "Darwin":
+                    search_set = [
+                        ("Contents/MacOS/stata-mp", "mp"),
+                        ("Contents/MacOS/stata-se", "se"),
+                        ("Contents/MacOS/stata", "be"),
+                        ("stata-mp", "mp"),
+                        ("stata-se", "se"),
+                        ("stata", "be"),
+                    ]
 
-            raise FileNotFoundError(
-                f"STATA_PATH points to directory '{path}', but no Stata executable was found within. "
-                "Point STATA_PATH directly to the Stata binary (e.g., C:\\Program Files\\Stata18\\StataMP-64.exe)."
-            )
+                for binary, edition in search_set:
+                    candidate = os.path.join(path, binary)
+                    if _is_executable(candidate, system):
+                        logger.info(
+                            "Found Stata via STATA_PATH directory: %s (%s)",
+                            candidate,
+                            edition,
+                        )
+                        return candidate, edition
+
+                raise FileNotFoundError(
+                    f"STATA_PATH points to directory '{path}', but no Stata executable was found within. "
+                    "Point STATA_PATH directly to the Stata binary "
+                    "(e.g., C:\\Program Files\\Stata19\\StataMP-64.exe)."
+                )
 
-        edition = "be"
-        lower_path = path.lower()
-        if "mp" in lower_path:
-            edition = "mp"
-        elif "se" in lower_path:
-            edition = "se"
-        elif "be" in lower_path:
             edition = "be"
-        if not os.path.exists(path):
-            raise FileNotFoundError(
-                f"STATA_PATH points to '{path}', but that file does not exist. "
-                "Update STATA_PATH to your Stata binary (e.g., "
-                "/Applications/StataNow/StataMP.app/Contents/MacOS/stata-mp or /usr/local/stata18/stata-mp)."
-            )
-        if not _is_executable(path, system):
-            raise PermissionError(
-                f"STATA_PATH points to '{path}', but it is not executable. "
-                "Ensure this is the Stata binary, not the .app directory."
+            lower_path = path.lower()
+            if "mp" in lower_path:
+                edition = "mp"
+            elif "se" in lower_path:
+                edition = "se"
+            elif "be" in lower_path:
+                edition = "be"
+
+            if not os.path.exists(path):
+                raise FileNotFoundError(
+                    f"STATA_PATH points to '{path}', but that file does not exist. "
+                    "Update STATA_PATH to your Stata binary (e.g., "
+                    "/Applications/StataNow/StataMP.app/Contents/MacOS/stata-mp, "
+                    "/usr/local/stata19/stata-mp or C:\\Program Files\\Stata19Now\\StataSE-64.exe)."
+                )
+            if not _is_executable(path, system):
+                raise PermissionError(
+                    f"STATA_PATH points to '{path}', but it is not executable. "
+                    "Ensure this is the Stata binary, not the .app directory."
+                )
+
+            logger.info("Using STATA_PATH override: %s (%s)", path, edition)
+            return path, edition
+
+        except Exception as exc:
+            stata_path_error = exc
+            logger.warning(
+                "STATA_PATH override failed (%s). Falling back to auto-discovery.",
+                exc,
             )
-        logger.info("Using STATA_PATH override: %s (%s)", path, edition)
-        return path, edition
 
     # 2. Platform-specific search
-    candidates = []  # List of (path, edition)
+    candidates: List[Tuple[str, str]] = []  # List of (path, edition)
 
     if system == "Darwin":  # macOS
         app_globs = [
@@ -147,17 +221,52 @@ def find_stata_path() -> Tuple[str, str]:
                         candidates.append((full_path, edition))
 
     elif system == "Windows":
+        # Include ProgramW6432 (real 64-bit Program Files) and hardcode fallbacks.
+        base_dirs = _dedupe_str_preserve(
+            [
+                os.environ.get("ProgramW6432", r"C:\Program Files"),
+                os.environ.get("ProgramFiles", r"C:\Program Files"),
+                os.environ.get("ProgramFiles(Arm)", r"C:\Program Files (Arm)"),
+                os.environ.get("ProgramFiles(x86)", r"C:\Program Files (x86)"),
+                r"C:\Program Files",
+                r"C:\Program Files (Arm)",
+                r"C:\Program Files (x86)",
+            ]
+        )
+
+        # Resolve for non-Windows hosts running Windows discovery tests.
         base_dirs = [
-            os.environ.get("ProgramFiles", "C:\\Program Files"),
-            os.environ.get("ProgramFiles(x86)", "C:\\Program Files (x86)"),
+            _resolve_windows_host_path(ntpath.normpath(bd), system) for bd in base_dirs
         ]
+        base_dirs = _dedupe_str_preserve(base_dirs)
 
+        # Look in a few plausible layouts:
+        #   base\Stata*\...
+        #   base\*\Stata*\...   (e.g., base\StataCorp\Stata19Now)
+        #   base\Stata*\*\...   (e.g., base\Stata\Stata19Now)
+        dir_globs: List[str] = []
         for base_dir in base_dirs:
-            for stata_dir in glob.glob(os.path.join(base_dir, "Stata*")):
-                for exe, edition in windows_binaries:
-                    full_path = os.path.join(stata_dir, exe)
-                    if os.path.exists(full_path):
-                        candidates.append((full_path, edition))
+            dir_globs.extend(
+                [
+                    os.path.join(base_dir, "Stata*"),
+                    os.path.join(base_dir, "*", "Stata*"),
+                    os.path.join(base_dir, "Stata*", "Stata*"),
+                ]
+            )
+        dir_globs = _dedupe_str_preserve(dir_globs)
+
+        stata_dirs: List[str] = []
+        for pattern in dir_globs:
+            stata_dirs.extend(glob.glob(pattern))
+        stata_dirs = _dedupe_str_preserve(stata_dirs)
+
+        for stata_dir in stata_dirs:
+            if not os.path.isdir(stata_dir):
+                continue
+            for exe, edition in windows_binaries:
+                full_path = os.path.join(stata_dir, exe)
+                if os.path.exists(full_path):
+                    candidates.append((full_path, edition))
 
     elif system == "Linux":
         home_base = os.environ.get("HOME") or os.path.expanduser("~")
@@ -197,7 +306,6 @@ def find_stata_path() -> Tuple[str, str]:
                         if os.path.exists(full_path):
                             candidates.append((full_path, edition))
 
-
     candidates = _dedupe_preserve(candidates)
 
     for path, edition in candidates:
@@ -210,10 +318,20 @@ def find_stata_path() -> Tuple[str, str]:
         logger.info("Auto-discovered Stata at %s (%s)", path, edition)
         return path, edition
 
+    if stata_path_error is not None:
+        raise FileNotFoundError(
+            "Could not automatically locate Stata after STATA_PATH failed. "
+            f"STATA_PATH error was: {stata_path_error}. "
+            "Fix STATA_PATH to point to the Stata executable, or install Stata in a standard location "
+            "(e.g., /Applications/StataNow/StataMP.app/Contents/MacOS/stata-mp, /usr/local/stata18/stata-mp, "
+            "or C:\\Program Files\\Stata18\\StataMP-64.exe)."
+        ) from stata_path_error
+
     raise FileNotFoundError(
         "Could not automatically locate Stata. "
         "Set STATA_PATH to your Stata executable (e.g., "
-        "/Applications/StataNow/StataMP.app/Contents/MacOS/stata-mp, /usr/local/stata18/stata-mp, or C:\\Program Files\\Stata18\\StataMP-64.exe)."
+        "/Applications/StataNow/StataMP.app/Contents/MacOS/stata-mp, /usr/local/stata18/stata-mp, "
+        "or C:\\Program Files\\Stata18\\StataMP-64.exe)."
     )
 
 
@@ -230,4 +348,4 @@ def main() -> int:
 
 
 if __name__ == "__main__":  # pragma: no cover - manual utility
-    raise SystemExit(main())
+    raise SystemExit(main())

mcp_stata/server.py

@@ -1,4 +1,5 @@
 import anyio
+from importlib.metadata import PackageNotFoundError, version
 from mcp.server.fastmcp import Context, FastMCP
 import mcp.types as types
 from .stata_client import StataClient
@@ -17,6 +18,12 @@ from .ui_http import UIChannelManager
 
 LOG_LEVEL = os.getenv("MCP_STATA_LOGLEVEL", "INFO").upper()
 logging.basicConfig(level=LOG_LEVEL, format="%(asctime)s %(levelname)s %(name)s - %(message)s")
+try:
+    _mcp_stata_version = version("mcp-stata")
+except PackageNotFoundError:
+    _mcp_stata_version = "unknown"
+logging.info("mcp-stata version: %s", _mcp_stata_version)
+logging.info("STATA_PATH env at startup: %s", os.getenv("STATA_PATH", "<not set>"))
 
 # Initialize FastMCP
 mcp = FastMCP("mcp_stata")

mcp_stata/stata_client.py

@@ -6,13 +6,15 @@ import re
 import subprocess
 import sys
 import threading
+from importlib.metadata import PackageNotFoundError, version
 import tempfile
 import time
 from contextlib import contextmanager
 from io import StringIO
-from typing import Any, Awaitable, Callable, Dict, List, Optional
+from typing import Any, Awaitable, Callable, Dict, List, Optional, Tuple
 
 import anyio
+from anyio import get_cancelled_exc_class
 
 from .discovery import find_stata_path
 from .models import (
@@ -32,6 +34,74 @@ from .graph_detector import StreamingGraphCache
 logger = logging.getLogger("mcp_stata")
 
 
+# ============================================================================
+# MODULE-LEVEL DISCOVERY CACHE
+# ============================================================================
+# This cache ensures Stata discovery runs exactly once per process lifetime
+_discovery_lock = threading.Lock()
+_discovery_result: Optional[Tuple[str, str]] = None  # (path, edition)
+_discovery_attempted = False
+_discovery_error: Optional[Exception] = None
+
+
+def _get_discovered_stata() -> Tuple[str, str]:
+    """
+    Get the discovered Stata path and edition, running discovery only once.
+    
+    Returns:
+        Tuple of (stata_executable_path, edition)
+    
+    Raises:
+        RuntimeError: If Stata discovery fails
+    """
+    global _discovery_result, _discovery_attempted, _discovery_error
+    
+    with _discovery_lock:
+        # If we've already successfully discovered Stata, return cached result
+        if _discovery_result is not None:
+            return _discovery_result
+        
+        # If we've already attempted and failed, re-raise the cached error
+        if _discovery_attempted and _discovery_error is not None:
+            raise RuntimeError(f"Stata binary not found: {_discovery_error}") from _discovery_error
+        
+        # This is the first attempt - run discovery
+        _discovery_attempted = True
+        
+        try:
+            # Log environment state once at first discovery
+            env_path = os.getenv("STATA_PATH")
+            if env_path:
+                logger.info("STATA_PATH env provided (raw): %s", env_path)
+            else:
+                logger.info("STATA_PATH env not set; attempting auto-discovery")
+            
+            try:
+                pkg_version = version("mcp-stata")
+            except PackageNotFoundError:
+                pkg_version = "unknown"
+            logger.info("mcp-stata version: %s", pkg_version)
+            
+            # Run discovery
+            stata_exec_path, edition = find_stata_path()
+            
+            # Cache the successful result
+            _discovery_result = (stata_exec_path, edition)
+            logger.info("Discovery found Stata at: %s (%s)", stata_exec_path, edition)
+            
+            return _discovery_result
+            
+        except FileNotFoundError as e:
+            _discovery_error = e
+            raise RuntimeError(f"Stata binary not found: {e}") from e
+        except PermissionError as e:
+            _discovery_error = e
+            raise RuntimeError(
+                f"Stata binary is not executable: {e}. "
+                "Point STATA_PATH directly to the Stata binary (e.g., .../Contents/MacOS/stata-mp)."
+            ) from e
+
+
 class StataClient:
     _initialized = False
     _exec_lock: threading.Lock
@@ -100,6 +170,62 @@ class StataClient:
                 logger.error(f"Failed to notify about graph cache: {e}")
         
         return graph_cache_callback
+    def _request_break_in(self) -> None:
+        """
+        Attempt to interrupt a running Stata command when cancellation is requested.
+
+        Uses the Stata sfi.breakIn hook when available; errors are swallowed because
+        cancellation should never crash the host process.
+        """
+        try:
+            import sfi  # type: ignore[import-not-found]
+
+            break_fn = getattr(sfi, "breakIn", None) or getattr(sfi, "break_in", None)
+            if callable(break_fn):
+                try:
+                    break_fn()
+                    logger.info("Sent breakIn() to Stata for cancellation")
+                except Exception as e:  # pragma: no cover - best-effort
+                    logger.warning(f"Failed to send breakIn() to Stata: {e}")
+            else:  # pragma: no cover - environment without Stata runtime
+                logger.debug("sfi.breakIn not available; cannot interrupt Stata")
+        except Exception as e:  # pragma: no cover - import failure or other
+            logger.debug(f"Unable to import sfi for cancellation: {e}")
+
+    async def _wait_for_stata_stop(self, timeout: float = 2.0) -> bool:
+        """
+        After requesting a break, poll the Stata interface so it can surface BreakError
+        and return control. This is best-effort and time-bounded.
+        """
+        deadline = time.monotonic() + timeout
+        try:
+            import sfi  # type: ignore[import-not-found]
+
+            toolkit = getattr(sfi, "SFIToolkit", None)
+            poll = getattr(toolkit, "pollnow", None) or getattr(toolkit, "pollstd", None)
+            BreakError = getattr(sfi, "BreakError", None)
+        except Exception:  # pragma: no cover
+            return False
+
+        if not callable(poll):
+            return False
+
+        last_exc: Optional[Exception] = None
+        while time.monotonic() < deadline:
+            try:
+                poll()
+            except Exception as e:  # pragma: no cover - depends on Stata runtime
+                last_exc = e
+                if BreakError is not None and isinstance(e, BreakError):
+                    logger.info("Stata BreakError detected; cancellation acknowledged by Stata")
+                    return True
+                # If Stata already stopped, break on any other exception.
+                break
+            await anyio.sleep(0.05)
+
+        if last_exc:
+            logger.debug(f"Cancellation poll exited with {last_exc}")
+        return False
 
     @contextmanager
     def _temp_cwd(self, cwd: Optional[str]):
@@ -114,24 +240,15 @@ class StataClient:
             os.chdir(prev)
 
     def init(self):
-        """Initializes usage of pystata."""
+        """Initializes usage of pystata using cached discovery results."""
         if self._initialized:
             return
 
         try:
             import stata_setup
-
-            try:
-                stata_exec_path, edition = find_stata_path()
-            except FileNotFoundError as e:
-                raise RuntimeError(f"Stata binary not found: {e}") from e
-            except PermissionError as e:
-                raise RuntimeError(
-                    f"Stata binary is not executable: {e}. "
-                    "Point STATA_PATH directly to the Stata binary (e.g., .../Contents/MacOS/stata-mp)."
-                ) from e
             
-            logger.info(f"Discovery found Stata at: {stata_exec_path} ({edition})")
+            # Get discovered Stata path (cached from first call)
+            stata_exec_path, edition = _get_discovered_stata()
 
             candidates = []
 
@@ -171,6 +288,7 @@ class StataClient:
                 try:
                     stata_setup.config(path, edition)
                     success = True
+                    logger.debug("stata_setup.config succeeded with path: %s", path)
                     break
                 except Exception:
                     continue
@@ -187,14 +305,6 @@ class StataClient:
             from pystata import stata  # type: ignore[import-not-found]
             self.stata = stata
             self._initialized = True
-
-            # Ensure a clean graph state for a fresh client. PyStata's backend is
-            # effectively global, so graph memory can otherwise leak across tests
-            # and separate StataClient instances.
-            try:
-                self.stata.run("capture graph drop _all", quietly=True)
-            except Exception:
-                pass
             
             # Initialize list_graphs TTL cache
             self._list_graphs_cache = None
@@ -205,11 +315,14 @@ class StataClient:
             # internal Stata graph names.
             self._graph_name_aliases: Dict[str, str] = {}
             self._graph_name_reverse: Dict[str, str] = {}
+            
+            logger.info("StataClient initialized successfully with %s (%s)", stata_exec_path, edition)
 
-        except ImportError:
-            # Fallback for when stata_setup isn't in PYTHONPATH yet?
-            # Usually users must have it installed. We rely on discovery logic.
-            raise RuntimeError("Could not import `stata_setup`. Ensure pystata is installed.")
+        except ImportError as e:
+            raise RuntimeError(
+                f"Failed to import stata_setup or pystata: {e}. "
+                "Ensure they are installed (pip install pystata stata-setup)."
+            ) from e
 
     def _make_valid_stata_name(self, name: str) -> str:
         """Create a valid Stata name (<=32 chars, [A-Za-z_][A-Za-z0-9_]*)."""
@@ -538,33 +651,42 @@ class StataClient:
         def _run_blocking() -> None:
             nonlocal rc, exc
             with self._exec_lock:
-                with self._temp_cwd(cwd):
-                    with self._redirect_io_streaming(tee, tee):
-                        try:
-                            if trace:
-                                self.stata.run("set trace on")
-                            ret = self.stata.run(code, echo=echo)
-                            # Some PyStata builds return output as a string rather than printing.
-                            if isinstance(ret, str) and ret:
-                                try:
-                                    tee.write(ret)
-                                except Exception:
-                                    pass
-                        except Exception as e:
-                            exc = e
-                        finally:
-                            rc = self._read_return_code()
-                            if trace:
-                                try:
-                                    self.stata.run("set trace off")
-                                except Exception:
-                                    pass
+                self._is_executing = True
+                try:
+                    with self._temp_cwd(cwd):
+                        with self._redirect_io_streaming(tee, tee):
+                            try:
+                                if trace:
+                                    self.stata.run("set trace on")
+                                ret = self.stata.run(code, echo=echo)
+                                # Some PyStata builds return output as a string rather than printing.
+                                if isinstance(ret, str) and ret:
+                                    try:
+                                        tee.write(ret)
+                                    except Exception:
+                                        pass
+                            except Exception as e:
+                                exc = e
+                            finally:
+                                rc = self._read_return_code()
+                                if trace:
+                                    try:
+                                        self.stata.run("set trace off")
+                                    except Exception:
+                                        pass
+                finally:
+                    self._is_executing = False
 
         try:
             if notify_progress is not None:
                 await notify_progress(0, None, "Running Stata command")
 
-            await anyio.to_thread.run_sync(_run_blocking)
+            await anyio.to_thread.run_sync(_run_blocking, abandon_on_cancel=True)
+        except get_cancelled_exc_class():
+            # Best-effort cancellation: signal Stata to break, wait briefly, then propagate.
+            self._request_break_in()
+            await self._wait_for_stata_stop()
+            raise
         finally:
             tee.close()
 
@@ -838,7 +960,11 @@ class StataClient:
                     await notify_progress(0, None, "Running do-file")
 
             try:
-                await anyio.to_thread.run_sync(_run_blocking)
+                await anyio.to_thread.run_sync(_run_blocking, abandon_on_cancel=True)
+            except get_cancelled_exc_class():
+                self._request_break_in()
+                await self._wait_for_stata_stop()
+                raise
             finally:
                 done.set()
                 tee.close()

mcp_stata/ui_http.py

@@ -455,16 +455,35 @@ def handle_page_request(manager: UIChannelManager, body: dict[str, Any], *, view
         dataset_id = view.dataset_id
         frame = view.frame
 
-    offset = int(body.get("offset", 0) or 0)
-    limit = int(body.get("limit", 0) or 0)
+    # Parse offset (default 0 is valid since offset >= 0)
+    try:
+        offset = int(body.get("offset") or 0)
+    except (ValueError, TypeError) as e:
+        raise HTTPError(400, "invalid_request", f"offset must be a valid integer, got: {body.get('offset')!r}")
+
+    # Parse limit (no default - must be explicitly provided)
+    limit_raw = body.get("limit")
+    if limit_raw is None:
+        raise HTTPError(400, "invalid_request", "limit is required")
+    try:
+        limit = int(limit_raw)
+    except (ValueError, TypeError) as e:
+        raise HTTPError(400, "invalid_request", f"limit must be a valid integer, got: {limit_raw!r}")
+
     vars_req = body.get("vars", [])
     include_obs_no = bool(body.get("includeObsNo", False))
-    max_chars_req = int(body.get("maxChars", max_chars) or max_chars)
+
+    # Parse maxChars
+    max_chars_raw = body.get("maxChars", max_chars)
+    try:
+        max_chars_req = int(max_chars_raw or max_chars)
+    except (ValueError, TypeError) as e:
+        raise HTTPError(400, "invalid_request", f"maxChars must be a valid integer, got: {max_chars_raw!r}")
 
     if offset < 0:
-        raise HTTPError(400, "invalid_request", "offset must be >= 0")
+        raise HTTPError(400, "invalid_request", f"offset must be >= 0, got: {offset}")
     if limit <= 0:
-        raise HTTPError(400, "invalid_request", "limit must be > 0")
+        raise HTTPError(400, "invalid_request", f"limit must be > 0, got: {limit}")
     if limit > max_limit:
         raise HTTPError(400, "request_too_large", f"limit must be <= {max_limit}")
     if max_chars_req <= 0:

{mcp_stata-1.6.2.dist-info → mcp_stata-1.6.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-stata
-Version: 1.6.2
+Version: 1.6.8
 Summary:  A lightweight Model Context Protocol (MCP) server for Stata. Execute commands, inspect data, retrieve stored results (`r()`/`e()`), and view graphs in your chat interface. Built for economists who want to integrate LLM assistance into their Stata workflow. 
 Project-URL: Homepage, https://github.com/tmonk/mcp-stata
 Project-URL: Repository, https://github.com/tmonk/mcp-stata
@@ -259,6 +259,14 @@ VS Code documents `.vscode/mcp.json` and the `servers` schema, including `type`
 * `get_stored_results()`: Get `r()` and `e()` scalars/macros as JSON.
 * `get_variable_list()`: JSON list of variables and labels.
 
+### Cancellation
+
+- Clients may cancel an in-flight request by sending the MCP notification `notifications/cancelled` with `params.requestId` set to the original tool call ID.
+- Client guidance:
+  1. Pass a `_meta.progressToken` when invoking the tool if you want progress updates (optional).
+  2. If you need to cancel, send `notifications/cancelled` with the same requestId. You may also stop tailing the log file path once you receive cancellation confirmation (the tool call will return an error indicating cancellation).
+  3. Be prepared for partial output in the log file; cancellation is best-effort and depends on Stata surfacing `BreakError`.
+
 Resources exposed for MCP clients:
 
 * `stata://data/summary` → `summarize`

mcp_stata-1.6.8.dist-info/RECORD

@@ -0,0 +1,14 @@
+mcp_stata/__init__.py,sha256=kJKKRn7lGuVCuS2-GaN5VoVcvnxtNlfuswW_VOlYqwg,98
+mcp_stata/discovery.py,sha256=J_XU1_AXRpqWg_ULV8xf4lT6RRN8MxOdpr1ioTi5TjQ,12951
+mcp_stata/graph_detector.py,sha256=-dJIU1Dq_c1eQSk4eegUi0gU2N-tFqjFGM0tE1E32KM,16066
+mcp_stata/models.py,sha256=QETpYKO3yILy_L6mhouVEanvUIvu4ww_CAAFuiP2YdM,1201
+mcp_stata/server.py,sha256=PV8ragGMeHT72zgVx5DJp3vt8CPqT8iwdvJ8GXSctds,15989
+mcp_stata/stata_client.py,sha256=TNJnlkZ0IoNoVXhKUw0_IYLiRNOwyL2wVmb1gWdiRUY,95981
+mcp_stata/streaming_io.py,sha256=GVaXgTtxx8YLY6RWqdTcO2M3QSqxLsefqkmnlNO1nTI,6974
+mcp_stata/ui_http.py,sha256=kkPYpqp-lQDXs_9qcs7hb16FtvNcag3rKSH7wvQX7Qo,22013
+mcp_stata/smcl/smcl2html.py,sha256=wi91mOMeV9MCmHtNr0toihNbaiDCNZ_NP6a6xEAzWLM,2624
+mcp_stata-1.6.8.dist-info/METADATA,sha256=V5mN_9vRL5f1aja0zrhMatBKb-_ZC6Ok3uOXfRBfYw4,13794
+mcp_stata-1.6.8.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+mcp_stata-1.6.8.dist-info/entry_points.txt,sha256=TcOgrtiTL4LGFEDb1pCrQWA-fUZvIujDOvQ-bWFh5Z8,52
+mcp_stata-1.6.8.dist-info/licenses/LICENSE,sha256=DZak_2itbUtvHzD3E7GNUYSRK6jdOJ-GqncQ2weavLA,34523
+mcp_stata-1.6.8.dist-info/RECORD,,

mcp_stata-1.6.2.dist-info/RECORD

@@ -1,14 +0,0 @@
-mcp_stata/__init__.py,sha256=kJKKRn7lGuVCuS2-GaN5VoVcvnxtNlfuswW_VOlYqwg,98
-mcp_stata/discovery.py,sha256=K8SK4oEnLESxnJWcBsLK76s85yNVdbLlfOql_Rf94B4,8390
-mcp_stata/graph_detector.py,sha256=-dJIU1Dq_c1eQSk4eegUi0gU2N-tFqjFGM0tE1E32KM,16066
-mcp_stata/models.py,sha256=QETpYKO3yILy_L6mhouVEanvUIvu4ww_CAAFuiP2YdM,1201
-mcp_stata/server.py,sha256=9_0i8xux11NpZ6yJwOniqQo-Cs3ph2mrkr0gwZ9GZ1I,15671
-mcp_stata/stata_client.py,sha256=floQMie0j7xI1PUeVu3mbmv4_eztw2CLjviZ7fdmClo,90673
-mcp_stata/streaming_io.py,sha256=GVaXgTtxx8YLY6RWqdTcO2M3QSqxLsefqkmnlNO1nTI,6974
-mcp_stata/ui_http.py,sha256=UhIPzCpBelVpZWUgwBnGpOCAEpG2vFVvX-TxRuyhkR0,21210
-mcp_stata/smcl/smcl2html.py,sha256=wi91mOMeV9MCmHtNr0toihNbaiDCNZ_NP6a6xEAzWLM,2624
-mcp_stata-1.6.2.dist-info/METADATA,sha256=buX6iqLIsnmtBlVueebezon9o3OYxL6I0DYmmwHOV0I,13141
-mcp_stata-1.6.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-mcp_stata-1.6.2.dist-info/entry_points.txt,sha256=TcOgrtiTL4LGFEDb1pCrQWA-fUZvIujDOvQ-bWFh5Z8,52
-mcp_stata-1.6.2.dist-info/licenses/LICENSE,sha256=DZak_2itbUtvHzD3E7GNUYSRK6jdOJ-GqncQ2weavLA,34523
-mcp_stata-1.6.2.dist-info/RECORD,,