lean-lsp-mcp 0.19.1__tar.gz → 0.20.0__tar.gz

{lean_lsp_mcp-0.19.1 → lean_lsp_mcp-0.20.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lean-lsp-mcp
-Version: 0.19.1
+Version: 0.20.0
 Summary: Lean Theorem Prover MCP
 Author-email: Oliver Dressler <hey@oli.show>
 License-Expression: MIT
@@ -11,6 +11,9 @@ License-File: LICENSE
 Requires-Dist: leanclient==0.9.2
 Requires-Dist: mcp[cli]==1.25.0
 Requires-Dist: orjson>=3.11.1
+Requires-Dist: certifi>=2024.0.0
+Provides-Extra: yaml
+Requires-Dist: PyYAML>=6.0; extra == "yaml"
 Provides-Extra: lint
 Requires-Dist: ruff>=0.2.0; extra == "lint"
 Provides-Extra: dev
@@ -266,8 +269,10 @@ l1c1-l1c6, severity: 3
 
 #### lean_multi_attempt
 
-Attempt multiple lean code snippets on a line and return goal state and diagnostics for each snippet.
-This tool is useful to screen different proof attempts before using the most promising one.
+Attempt multiple tactics on a line and return goal state and diagnostics for each.
+Useful to screen different proof attempts before committing to one.
+
+When `LEAN_REPL=true`, uses the REPL tactic mode for up to 5x faster execution (see [Environment Variables](#environment-variables)).
 
 <details>
 <summary>Example output (attempting `rw [Nat.pow_sub (Fintype.card_pos_of_nonempty S)]` and `by_contra h_neq`)</summary>
@@ -483,7 +488,12 @@ This MCP server works out-of-the-box without any configuration. However, a few o
 ### Environment Variables
 
 - `LEAN_LOG_LEVEL`: Log level for the server. Options are "INFO", "WARNING", "ERROR", "NONE". Defaults to "INFO".
+- `LEAN_LOG_FILE_CONFIG`: Config file path for logging, with priority over `LEAN_LOG_LEVEL`. If not set, logs are printed to stdout.
 - `LEAN_PROJECT_PATH`: Path to your Lean project root. Set this if the server cannot automatically detect your project.
+- `LEAN_REPL`: Set to `true`, `1`, or `yes` to enable fast REPL-based `lean_multi_attempt` (~5x faster, see [REPL Setup](#repl-setup)).
+- `LEAN_REPL_PATH`: Path to the `repl` binary. Auto-detected from `.lake/packages/repl/` if not set.
+- `LEAN_REPL_TIMEOUT`: Per-command timeout in seconds (default: 60).
+- `LEAN_REPL_MEM_MB`: Max memory per REPL in MB (default: 8192). Only enforced on Linux/macOS.
 - `LEAN_LSP_MCP_TOKEN`: Secret token for bearer authentication when using `streamable-http` or `sse` transport.
 - `LEAN_STATE_SEARCH_URL`: URL for a self-hosted [premise-search.com](https://premise-search.com) instance.
 - `LEAN_HAMMER_URL`: URL for a self-hosted [Lean Hammer Premise Search](https://github.com/hanwenzhu/lean-premise-server) instance.
@@ -544,6 +554,36 @@ uvx lean-lsp-mcp --transport streamable-http
 
 Clients should then include the token in the `Authorization` header.
 
+### REPL Setup
+
+Enable fast REPL-based `lean_multi_attempt` (~5x faster). Uses [leanprover-community/repl](https://github.com/leanprover-community/repl) tactic mode.
+
+**1. Add REPL to your Lean project's `lakefile.toml`:**
+
+```toml
+[[require]]
+name = "repl"
+git = "https://github.com/leanprover-community/repl"
+rev = "v4.25.0"  # Match your Lean version
+```
+
+**2. Build it:**
+
+```bash
+lake build repl
+```
+
+**3. Enable via CLI or environment variable:**
+
+```bash
+uvx lean-lsp-mcp --repl
+
+# Or via environment variable
+export LEAN_REPL=true
+```
+
+The REPL binary is auto-detected from `.lake/packages/repl/`. Falls back to LSP if not found.
+
 ### Local Loogle
 
 Run loogle locally to avoid the remote API's rate limit (3 req/30s). First run takes ~5-10 minutes to build; subsequent runs start in seconds.
@@ -590,9 +630,15 @@ uv sync --all-extras
 uv run pytest tests
 ```
 
-## Publications using lean-lsp-mcp
+## Publications and Formalization Projects using lean-lsp-mcp
 
 - Ax-Prover: A Deep Reasoning Agentic Framework for Theorem Proving in Mathematics and Quantum Physics [arxiv](https://arxiv.org/abs/2510.12787)
+- Numina-Lean-Agent: An Open and General Agentic Reasoning System for Formal Mathematics [arxiv](https://arxiv.org/abs/2601.14027) [github](https://github.com/project-numina/numina-lean-agent)
+- A Group-Theoretic Approach to Shannon Capacity of Graphs and a Limit Theorem from Lattice Packings [github](https://github.com/jzuiddam/GroupTheoreticShannonCapacity/)
+
+## Talks
+
+lean-lsp-mcp: Tools for agentic interaction with Lean (Lean Together 2026) [youtube](https://www.youtube.com/watch?v=uttbYaTaF-E)
 
 ## Related Projects
 

lean_lsp_mcp-0.19.1/src/lean_lsp_mcp.egg-info/PKG-INFO → lean_lsp_mcp-0.20.0/README.md

@@ -1,26 +1,3 @@
-Metadata-Version: 2.4
-Name: lean-lsp-mcp
-Version: 0.19.1
-Summary: Lean Theorem Prover MCP
-Author-email: Oliver Dressler <hey@oli.show>
-License-Expression: MIT
-Project-URL: Repository, https://github.com/oOo0oOo/lean-lsp-mcp
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: leanclient==0.9.2
-Requires-Dist: mcp[cli]==1.25.0
-Requires-Dist: orjson>=3.11.1
-Provides-Extra: lint
-Requires-Dist: ruff>=0.2.0; extra == "lint"
-Provides-Extra: dev
-Requires-Dist: ruff>=0.2.0; extra == "dev"
-Requires-Dist: pytest>=8.3; extra == "dev"
-Requires-Dist: anyio>=4.4; extra == "dev"
-Requires-Dist: pytest-asyncio>=0.23; extra == "dev"
-Requires-Dist: pytest-timeout>=2.3; extra == "dev"
-Dynamic: license-file
-
 <h1 align="center">
   lean-lsp-mcp
 </h1>
@@ -266,8 +243,10 @@ l1c1-l1c6, severity: 3
 
 #### lean_multi_attempt
 
-Attempt multiple lean code snippets on a line and return goal state and diagnostics for each snippet.
-This tool is useful to screen different proof attempts before using the most promising one.
+Attempt multiple tactics on a line and return goal state and diagnostics for each.
+Useful to screen different proof attempts before committing to one.
+
+When `LEAN_REPL=true`, uses the REPL tactic mode for up to 5x faster execution (see [Environment Variables](#environment-variables)).
 
 <details>
 <summary>Example output (attempting `rw [Nat.pow_sub (Fintype.card_pos_of_nonempty S)]` and `by_contra h_neq`)</summary>
@@ -483,7 +462,12 @@ This MCP server works out-of-the-box without any configuration. However, a few o
 ### Environment Variables
 
 - `LEAN_LOG_LEVEL`: Log level for the server. Options are "INFO", "WARNING", "ERROR", "NONE". Defaults to "INFO".
+- `LEAN_LOG_FILE_CONFIG`: Config file path for logging, with priority over `LEAN_LOG_LEVEL`. If not set, logs are printed to stdout.
 - `LEAN_PROJECT_PATH`: Path to your Lean project root. Set this if the server cannot automatically detect your project.
+- `LEAN_REPL`: Set to `true`, `1`, or `yes` to enable fast REPL-based `lean_multi_attempt` (~5x faster, see [REPL Setup](#repl-setup)).
+- `LEAN_REPL_PATH`: Path to the `repl` binary. Auto-detected from `.lake/packages/repl/` if not set.
+- `LEAN_REPL_TIMEOUT`: Per-command timeout in seconds (default: 60).
+- `LEAN_REPL_MEM_MB`: Max memory per REPL in MB (default: 8192). Only enforced on Linux/macOS.
 - `LEAN_LSP_MCP_TOKEN`: Secret token for bearer authentication when using `streamable-http` or `sse` transport.
 - `LEAN_STATE_SEARCH_URL`: URL for a self-hosted [premise-search.com](https://premise-search.com) instance.
 - `LEAN_HAMMER_URL`: URL for a self-hosted [Lean Hammer Premise Search](https://github.com/hanwenzhu/lean-premise-server) instance.
@@ -544,6 +528,36 @@ uvx lean-lsp-mcp --transport streamable-http
 
 Clients should then include the token in the `Authorization` header.
 
+### REPL Setup
+
+Enable fast REPL-based `lean_multi_attempt` (~5x faster). Uses [leanprover-community/repl](https://github.com/leanprover-community/repl) tactic mode.
+
+**1. Add REPL to your Lean project's `lakefile.toml`:**
+
+```toml
+[[require]]
+name = "repl"
+git = "https://github.com/leanprover-community/repl"
+rev = "v4.25.0"  # Match your Lean version
+```
+
+**2. Build it:**
+
+```bash
+lake build repl
+```
+
+**3. Enable via CLI or environment variable:**
+
+```bash
+uvx lean-lsp-mcp --repl
+
+# Or via environment variable
+export LEAN_REPL=true
+```
+
+The REPL binary is auto-detected from `.lake/packages/repl/`. Falls back to LSP if not found.
+
 ### Local Loogle
 
 Run loogle locally to avoid the remote API's rate limit (3 req/30s). First run takes ~5-10 minutes to build; subsequent runs start in seconds.
@@ -590,9 +604,15 @@ uv sync --all-extras
 uv run pytest tests
 ```
 
-## Publications using lean-lsp-mcp
+## Publications and Formalization Projects using lean-lsp-mcp
 
 - Ax-Prover: A Deep Reasoning Agentic Framework for Theorem Proving in Mathematics and Quantum Physics [arxiv](https://arxiv.org/abs/2510.12787)
+- Numina-Lean-Agent: An Open and General Agentic Reasoning System for Formal Mathematics [arxiv](https://arxiv.org/abs/2601.14027) [github](https://github.com/project-numina/numina-lean-agent)
+- A Group-Theoretic Approach to Shannon Capacity of Graphs and a Limit Theorem from Lattice Packings [github](https://github.com/jzuiddam/GroupTheoreticShannonCapacity/)
+
+## Talks
+
+lean-lsp-mcp: Tools for agentic interaction with Lean (Lean Together 2026) [youtube](https://www.youtube.com/watch?v=uttbYaTaF-E)
 
 ## Related Projects
 

{lean_lsp_mcp-0.19.1 → lean_lsp_mcp-0.20.0}/pyproject.toml

@@ -1,20 +1,27 @@
 [project]
 name = "lean-lsp-mcp"
-version = "0.19.1"
+version = "0.20.0"
 description = "Lean Theorem Prover MCP"
 authors = [{ name = "Oliver Dressler", email = "hey@oli.show" }]
 readme = "README.md"
 requires-python = ">=3.10"
 license = "MIT"
-dependencies = ["leanclient==0.9.2", "mcp[cli]==1.25.0", "orjson>=3.11.1"]
+dependencies = ["leanclient==0.9.2", "mcp[cli]==1.25.0", "orjson>=3.11.1", "certifi>=2024.0.0"]
 
 [project.urls]
 Repository = "https://github.com/oOo0oOo/lean-lsp-mcp"
 
 [project.optional-dependencies]
+yaml = ["PyYAML>=6.0"]
 lint = ["ruff>=0.2.0"]
 dev = ["ruff>=0.2.0", "pytest>=8.3", "anyio>=4.4", "pytest-asyncio>=0.23", "pytest-timeout>=2.3"]
 
+[tool.ruff]
+exclude = [
+    "tests/test_project/.lake",
+    "tests/mathlib_project/.lake",
+]
+
 [tool.pytest.ini_options]
 asyncio_mode = "auto"
 markers = ["slow: marks tests as slow (deselect with '-m \"not slow\"')"]

{lean_lsp_mcp-0.19.1 → lean_lsp_mcp-0.20.0}/src/lean_lsp_mcp/__init__.py

@@ -36,6 +36,16 @@ def main():
         type=str,
         help="Override loogle cache location (default: ~/.cache/lean-lsp-mcp/loogle)",
     )
+    parser.add_argument(
+        "--repl",
+        action="store_true",
+        help="Enable fast REPL-based multi-attempt (~5x faster). Requires Lean REPL.",
+    )
+    parser.add_argument(
+        "--repl-timeout",
+        type=int,
+        help="REPL command timeout in seconds (default: 60)",
+    )
     args = parser.parse_args()
 
     # Set env vars from CLI args (CLI takes precedence over env vars)
@@ -43,6 +53,10 @@ def main():
         os.environ["LEAN_LOOGLE_LOCAL"] = "true"
     if args.loogle_cache_dir:
         os.environ["LEAN_LOOGLE_CACHE_DIR"] = args.loogle_cache_dir
+    if args.repl:
+        os.environ["LEAN_REPL"] = "true"
+    if args.repl_timeout:
+        os.environ["LEAN_REPL_TIMEOUT"] = str(args.repl_timeout)
 
     mcp.settings.host = args.host
     mcp.settings.port = args.port

{lean_lsp_mcp-0.19.1 → lean_lsp_mcp-0.20.0}/src/lean_lsp_mcp/instructions.py

@@ -16,19 +16,19 @@ INSTRUCTIONS = """## General Rules
 - **lean_profile_proof**: Profile a theorem for performance. Shows tactic hotspots. SLOW!
 
 ## Search Tools (rate limited)
-- **lean_leansearch** (3/30s): Natural language → mathlib
-- **lean_loogle** (3/30s): Type pattern → mathlib
+- **lean_leansearch** (3/30s): Natural language -> mathlib
+- **lean_loogle** (3/30s): Type pattern -> mathlib
 - **lean_leanfinder** (10/30s): Semantic/conceptual search
-- **lean_state_search** (3/30s): Goal → closing lemmas
-- **lean_hammer_premise** (3/30s): Goal → premises for simp/aesop
+- **lean_state_search** (3/30s): Goal -> closing lemmas
+- **lean_hammer_premise** (3/30s): Goal -> premises for simp/aesop
 
 ## Search Decision Tree
-1. "Does X exist locally?" → lean_local_search
-2. "I need a lemma that says X" → lean_leansearch
-3. "Find lemma with type pattern" → lean_loogle
-4. "What's the Lean name for concept X?" → lean_leanfinder
-5. "What closes this goal?" → lean_state_search
-6. "What to feed simp?" → lean_hammer_premise
+1. "Does X exist locally?" -> lean_local_search
+2. "I need a lemma that says X" -> lean_leansearch
+3. "Find lemma with type pattern" -> lean_loogle
+4. "What's the Lean name for concept X?" -> lean_leanfinder
+5. "What closes this goal?" -> lean_state_search
+6. "What to feed simp?" -> lean_hammer_premise
 
 After finding a name: lean_local_search to verify, lean_hover_info for signature.
 
@@ -37,4 +37,5 @@ List tools return JSON arrays. Empty = `[]`.
 
 ## Error Handling
 Check `isError` in responses: `true` means failure (timeout/LSP error), while `[]` with `isError: false` means no results found.
+
 """

{lean_lsp_mcp-0.19.1 → lean_lsp_mcp-0.20.0}/src/lean_lsp_mcp/loogle.py

@@ -8,12 +8,14 @@ import json
 import logging
 import os
 import shutil
+import ssl
 import subprocess
 import urllib.parse
 import urllib.request
 from pathlib import Path
 from typing import Any
 
+import certifi
 import orjson
 
 from lean_lsp_mcp.models import LoogleResult
@@ -35,7 +37,8 @@ def loogle_remote(query: str, num_results: int) -> list[LoogleResult] | str:
             f"https://loogle.lean-lang.org/json?q={urllib.parse.quote(query)}",
             headers={"User-Agent": "lean-lsp-mcp/0.1"},
         )
-        with urllib.request.urlopen(req, timeout=10) as response:
+        ssl_ctx = ssl.create_default_context(cafile=certifi.where())
+        with urllib.request.urlopen(req, timeout=10, context=ssl_ctx) as response:
             results = orjson.loads(response.read())
         if "hits" not in results:
             return "No results found."
@@ -139,9 +142,12 @@ class LoogleManager:
             self._run(["lake", "exe", "cache", "get"], timeout=600)
         except Exception as e:
             logger.warning(f"Cache download: {e}")
-        logger.info("Building loogle...")
+        logger.info("Building loogle (this may a few minutes)...")
         try:
-            return self._run(["lake", "build"], timeout=900).returncode == 0
+            result = self._run(["lake", "build"], timeout=900)
+            if result.returncode != 0:
+                logger.error(f"Build failed: {result.stderr[:1000]}")
+            return result.returncode == 0
         except Exception as e:
             logger.error(f"Build error: {e}")
             return False

lean_lsp_mcp-0.20.0/src/lean_lsp_mcp/repl.py

@@ -0,0 +1,260 @@
+"""Lean REPL for fast multi-attempt tactic execution using tactic mode."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+import platform
+from dataclasses import dataclass, field
+from typing import Any
+
+if platform.system() != "Windows":
+    import resource
+
+
+class ReplError(Exception):
+    pass
+
+
+@dataclass
+class SnippetResult:
+    goals: list[str] = field(default_factory=list)
+    messages: list[dict[str, Any]] = field(default_factory=list)
+    proof_status: str | None = None
+    error: str | None = None
+
+
+def repl_enabled() -> bool:
+    return os.environ.get("LEAN_REPL", "").lower() in ("1", "true", "yes")
+
+
+def find_repl_binary(project_dir: str | None = None) -> str | None:
+    """Find REPL binary: env var > .lake/packages > PATH."""
+    import shutil
+    from pathlib import Path
+
+    # 1. Explicit env var
+    if path := os.environ.get("LEAN_REPL_PATH"):
+        return path if Path(path).exists() or shutil.which(path) else None
+
+    # 2. Auto-detect from .lake/packages (common location after `lake build`)
+    if project_dir:
+        candidates = [
+            Path(project_dir)
+            / ".lake"
+            / "packages"
+            / "repl"
+            / ".lake"
+            / "build"
+            / "bin"
+            / "repl",
+            Path(project_dir) / ".lake" / "build" / "bin" / "repl",
+        ]
+        for p in candidates:
+            if p.exists():
+                return str(p)
+
+    # 3. Fall back to PATH
+    if found := shutil.which("repl"):
+        return found
+
+    return None
+
+
+def _split_imports(code: str) -> tuple[str, str]:
+    """Split code into (header with imports, body)."""
+    lines = code.splitlines()
+    i = 0
+    while i < len(lines) and (not lines[i].strip() or lines[i].startswith("import ")):
+        i += 1
+
+    # Deduplicate imports while preserving order
+    imports = [ln.strip() for ln in lines[:i] if ln.startswith("import ")]
+    header = "\n".join(dict.fromkeys(imports))
+    return header, "\n".join(lines[i:])
+
+
+class Repl:
+    """Lean REPL using tactic mode for fast multi-attempt."""
+
+    def __init__(self, project_dir: str, repl_path: str | None = None):
+        self.project_dir = project_dir
+        self.repl_path = repl_path or find_repl_binary(project_dir) or "repl"
+        self.timeout = int(os.environ.get("LEAN_REPL_TIMEOUT", "60"))
+        self.mem_mb = int(os.environ.get("LEAN_REPL_MEM_MB", "8192"))
+        self._proc: asyncio.subprocess.Process | None = None
+        self._header: str | None = None
+        self._header_env: int | None = None
+        self._lock = asyncio.Lock()
+
+    async def _start(self) -> None:
+        """Start REPL subprocess."""
+        kwargs: dict[str, Any] = {
+            "cwd": self.project_dir,
+            "stdin": asyncio.subprocess.PIPE,
+            "stdout": asyncio.subprocess.PIPE,
+            "stderr": asyncio.subprocess.PIPE,
+        }
+        if platform.system() != "Windows":
+            kwargs["start_new_session"] = True
+            # Memory limit on Unix systems
+            if platform.system() == "Linux":
+                limit = resource.RLIMIT_AS  # Virtual memory
+            else:  # macOS
+                limit = resource.RLIMIT_RSS  # Resident set size
+            mem = self.mem_mb * 1024 * 1024
+            kwargs["preexec_fn"] = lambda: resource.setrlimit(limit, (mem, mem))
+        self._proc = await asyncio.create_subprocess_exec(
+            "lake", "env", self.repl_path, **kwargs
+        )
+
+    async def _send(self, cmd: dict[str, Any]) -> dict[str, Any]:
+        """Send command and return response."""
+        if not self._proc or not self._proc.stdin or not self._proc.stdout:
+            raise ReplError("REPL not running")
+
+        self._proc.stdin.write((json.dumps(cmd) + "\n\n").encode())
+        await self._proc.stdin.drain()
+
+        lines = []
+        while True:
+            line = await self._proc.stdout.readline()
+            if not line or not line.strip():
+                break
+            lines.append(line)
+
+        if not lines:
+            raise ReplError("No response from REPL")
+        return json.loads(b"".join(lines))
+
+    async def _send_cmd(self, code: str, env: int | None = None) -> dict[str, Any]:
+        """Send a command (code) to the REPL."""
+        cmd: dict[str, Any] = {"cmd": code}
+        if env is not None:
+            cmd["env"] = env
+        return await self._send(cmd)
+
+    async def _send_tactic(self, tactic: str, proof_state: int) -> dict[str, Any]:
+        """Send a tactic to run in a proof state."""
+        return await self._send({"tactic": tactic, "proofState": proof_state})
+
+    async def _ensure_header(self, header: str) -> int | None:
+        """Ensure REPL is running with given header, return header env."""
+        if self._header != header:
+            await self.close()
+            self._header = header
+            self._header_env = None
+
+        if not self._proc or self._proc.returncode is not None:
+            await self._start()
+            if header:
+                resp = await self._send_cmd(header, env=None)
+                if "error" in resp:
+                    raise ReplError(f"Failed to load imports: {resp['error']}")
+                self._header_env = resp.get("env")
+
+        return self._header_env
+
+    async def run_snippets(
+        self, base_code: str, snippets: list[str]
+    ) -> list[SnippetResult]:
+        """Run multiple tactic snippets using tactic mode.
+
+        1. Load header (imports) - cached across calls
+        2. Send body + sorry to get proofState
+        3. Run each tactic via tactic mode (very fast)
+        """
+        header, body = _split_imports(base_code)
+
+        async with self._lock:
+            try:
+                # Load imports (cached)
+                header_env = await asyncio.wait_for(
+                    self._ensure_header(header), timeout=self.timeout
+                )
+
+                # Send body with sorry to get proof state
+                if not body.strip():
+                    return [SnippetResult(error="No proof body") for _ in snippets]
+
+                # Ensure proper whitespace before sorry
+                body_with_sorry = body.rstrip() + "\n  sorry"
+                resp = await asyncio.wait_for(
+                    self._send_cmd(body_with_sorry, env=header_env),
+                    timeout=self.timeout,
+                )
+
+                if "error" in resp:
+                    return [SnippetResult(error=resp["error"]) for _ in snippets]
+
+                # Get proof state from the sorry
+                sorries = resp.get("sorries", [])
+                if not sorries:
+                    # No sorry = no proof goal, check messages for errors
+                    msgs = resp.get("messages", [])
+                    err = "; ".join(
+                        m.get("data", "") for m in msgs if m.get("severity") == "error"
+                    )
+                    return [
+                        SnippetResult(error=err or "No proof goal found")
+                        for _ in snippets
+                    ]
+
+                proof_state = sorries[0].get("proofState")
+                if proof_state is None:
+                    return [
+                        SnippetResult(error="No proofState returned") for _ in snippets
+                    ]
+
+                # Run each tactic in tactic mode
+                results = []
+                for snippet in snippets:
+                    try:
+                        resp = await asyncio.wait_for(
+                            self._send_tactic(snippet.strip(), proof_state),
+                            timeout=self.timeout,
+                        )
+
+                        if "error" in resp:
+                            # Lean error (tactic failed)
+                            results.append(SnippetResult(error=resp["error"]))
+                        else:
+                            goals = resp.get("goals", [])
+                            messages = resp.get("messages", [])
+                            proof_status = resp.get("proofStatus")
+                            results.append(
+                                SnippetResult(
+                                    goals=goals,
+                                    messages=messages,
+                                    proof_status=proof_status,
+                                )
+                            )
+                    except Exception as e:
+                        results.append(SnippetResult(error=str(e)))
+
+                return results
+
+            except Exception as e:
+                await self.close()
+                raise ReplError(str(e)) from e
+
+    async def close(self) -> None:
+        if not self._proc:
+            return
+        proc, self._proc = self._proc, None
+        self._header = None
+        self._header_env = None
+        try:
+            if platform.system() != "Windows":
+                os.killpg(os.getpgid(proc.pid), 9)
+            else:
+                proc.kill()
+        except (ProcessLookupError, OSError):
+            pass
+        try:
+            await asyncio.wait_for(proc.wait(), timeout=1.0)
+        except asyncio.TimeoutError:
+            pass
+        if hasattr(proc, "_transport") and proc._transport:
+            proc._transport.close()