lean-lsp-mcp 0.16.1__py3-none-any.whl → 0.17.0__py3-none-any.whl

lean_lsp_mcp/instructions.py

@@ -33,4 +33,7 @@ After finding a name: lean_local_search to verify, lean_hover_info for signature
 
 ## Return Formats
 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/loogle.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import asyncio
+import hashlib
 import json
 import logging
 import os
@@ -34,7 +35,7 @@ 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=20) as response:
+        with urllib.request.urlopen(req, timeout=10) as response:
             results = orjson.loads(response.read())
         if "hits" not in results:
             return "No results found."
@@ -52,18 +53,25 @@ def loogle_remote(query: str, num_results: int) -> list[LoogleResult] | str:
 
 
 class LoogleManager:
-    """Manages local loogle installation and async subprocess."""
+    """Manages local loogle installation and async subprocess.
+
+    Args:
+        cache_dir: Directory for loogle repo and indices (default: ~/.cache/lean-lsp-mcp/loogle)
+        project_path: Optional Lean project path to index its .lake/packages dependencies
+    """
 
     REPO_URL = "https://github.com/nomeata/loogle.git"
     READY_SIGNAL = "Loogle is ready."
 
-    def __init__(self, cache_dir: Path | None = None):
+    def __init__(self, cache_dir: Path | None = None, project_path: Path | None = None):
         self.cache_dir = cache_dir or get_cache_dir()
         self.repo_dir = self.cache_dir / "repo"
         self.index_dir = self.cache_dir / "index"
+        self.project_path = project_path
         self.process: asyncio.subprocess.Process | None = None
         self._ready = False
         self._lock = asyncio.Lock()
+        self._extra_paths: list[Path] = []
 
     @property
     def binary_path(self) -> Path:
@@ -181,21 +189,54 @@ class LoogleManager:
             return False, err
         return True, ""
 
+    def _discover_project_paths(self) -> list[Path]:
+        """Find .lake/packages lib paths from the user's project."""
+        if not self.project_path:
+            return []
+        paths = []
+        # Check packages directory
+        lake_packages = self.project_path / ".lake" / "packages"
+        if lake_packages.exists():
+            for pkg_dir in lake_packages.iterdir():
+                if not pkg_dir.is_dir():
+                    continue
+                lib_path = pkg_dir / ".lake" / "build" / "lib" / "lean"
+                if lib_path.exists():
+                    paths.append(lib_path)
+        # Also add the project's own build output
+        project_lib = self.project_path / ".lake" / "build" / "lib" / "lean"
+        if project_lib.exists():
+            paths.append(project_lib)
+        return sorted(paths)
+
     def _get_index_path(self) -> Path:
-        return self.index_dir / f"mathlib-{self._get_mathlib_version()}.idx"
+        base = f"mathlib-{self._get_mathlib_version()}"
+        if self._extra_paths:
+            # Include hash of extra paths for project-specific index
+            paths_str = ":".join(str(p) for p in sorted(self._extra_paths))
+            path_hash = hashlib.sha256(paths_str.encode()).hexdigest()[:8]
+            return self.index_dir / f"{base}-{path_hash}.idx"
+        return self.index_dir / f"{base}.idx"
 
     def _cleanup_old_indices(self) -> None:
-        """Remove old index files from previous mathlib versions."""
+        """Remove old index files from previous mathlib versions.
+
+        Cleans up both mathlib-only indexes (mathlib-<version>.idx) and
+        project-specific indexes (mathlib-<version>-<hash>.idx) that don't
+        match the current mathlib version.
+        """
         if not self.index_dir.exists():
             return
-        current = self._get_index_path()
+        current_mathlib = f"mathlib-{self._get_mathlib_version()}"
         for idx in self.index_dir.glob("*.idx"):
-            if idx != current:
-                try:
-                    idx.unlink()
-                    logger.info(f"Removed old index: {idx.name}")
-                except Exception:
-                    pass
+            # Keep indexes with current mathlib version (both base and project-specific)
+            if idx.name.startswith(current_mathlib):
+                continue
+            try:
+                idx.unlink()
+                logger.info(f"Removed old index: {idx.name}")
+            except Exception:
+                pass
 
     def _build_index(self) -> Path | None:
         index_path = self._get_index_path()
@@ -205,17 +246,37 @@ class LoogleManager:
             return None
         self.index_dir.mkdir(parents=True, exist_ok=True)
         self._cleanup_old_indices()
-        logger.info("Building search index...")
-        try:
-            self._run(
-                [str(self.binary_path), "--write-index", str(index_path), "--json", ""],
-                timeout=600,
+
+        # Build command with extra paths
+        cmd = [str(self.binary_path), "--write-index", str(index_path), "--json"]
+        for path in self._extra_paths:
+            cmd.extend(["--path", str(path)])
+        cmd.append("")  # Empty query for index building
+
+        if self._extra_paths:
+            logger.info(
+                f"Building search index with {len(self._extra_paths)} extra paths..."
             )
+        else:
+            logger.info("Building search index...")
+        try:
+            self._run(cmd, timeout=600)
             return index_path if index_path.exists() else None
         except Exception as e:
             logger.error(f"Index build error: {e}")
             return None
 
+    def set_project_path(self, project_path: Path | None) -> bool:
+        """Update project path and rediscover extra paths. Returns True if paths changed."""
+        self.project_path = project_path
+        new_paths = self._discover_project_paths()
+        if new_paths != self._extra_paths:
+            self._extra_paths = new_paths
+            if new_paths:
+                logger.info(f"Discovered {len(new_paths)} project library paths")
+            return True
+        return False
+
     def ensure_installed(self) -> bool:
         ok, err = self._check_prerequisites()
         if not ok:
@@ -223,6 +284,10 @@ class LoogleManager:
             return False
         if not self._clone_repo() or not self._build_loogle():
             return False
+        # Discover project paths before building index
+        self._extra_paths = self._discover_project_paths()
+        if self._extra_paths:
+            logger.info(f"Indexing {len(self._extra_paths)} project library paths")
         if not self._build_index():
             logger.warning("Index build failed, loogle will build on startup")
         return self.is_installed
@@ -234,10 +299,26 @@ class LoogleManager:
         if not ok:
             logger.error(f"Loogle environment check failed: {err}")
             return False
+
+        # Check if project paths changed and we need to rebuild index
+        if self.project_path:
+            new_paths = self._discover_project_paths()
+            if new_paths != self._extra_paths:
+                self._extra_paths = new_paths
+                # Build new index if paths changed
+                self._build_index()
+
         cmd = [str(self.binary_path), "--json", "--interactive"]
         if (idx := self._get_index_path()).exists():
             cmd.extend(["--read-index", str(idx)])
-        logger.info("Starting loogle subprocess...")
+        # Add extra paths for runtime search (in case not all are indexed)
+        for path in self._extra_paths:
+            cmd.extend(["--path", str(path)])
+
+        if self._extra_paths:
+            logger.info(f"Starting loogle with {len(self._extra_paths)} extra paths...")
+        else:
+            logger.info("Starting loogle subprocess...")
         try:
             self.process = await asyncio.create_subprocess_exec(
                 *cmd,

lean_lsp_mcp/models.py

@@ -46,7 +46,15 @@ class DiagnosticMessage(BaseModel):
 
 class GoalState(BaseModel):
     line_context: str = Field(description="Source line where goals were queried")
-    goals: str = Field(description="Goal state (before→after if column omitted)")
+    goals: Optional[List[str]] = Field(
+        None, description="Goal list at specified column position"
+    )
+    goals_before: Optional[List[str]] = Field(
+        None, description="Goals at line start (when column omitted)"
+    )
+    goals_after: Optional[List[str]] = Field(
+        None, description="Goals at line end (when column omitted)"
+    )
 
 
 class CompletionItem(BaseModel):
@@ -94,8 +102,8 @@ class FileOutline(BaseModel):
 
 class AttemptResult(BaseModel):
     snippet: str = Field(description="Code snippet that was tried")
-    goal_state: Optional[str] = Field(
-        None, description="Goal state after applying snippet"
+    goals: List[str] = Field(
+        default_factory=list, description="Goal list after applying snippet"
     )
     diagnostics: List[DiagnosticMessage] = Field(
         default_factory=list, description="Diagnostics for this attempt"
@@ -118,3 +126,80 @@ class RunResult(BaseModel):
 class DeclarationInfo(BaseModel):
     file_path: str = Field(description="Path to declaration file")
     content: str = Field(description="File content")
+
+
+# Wrapper models for list-returning tools
+# FastMCP flattens bare lists into separate TextContent blocks, causing serialization issues.
+# Wrapping in a model ensures proper JSON serialization.
+
+
+class DiagnosticsResult(BaseModel):
+    """Wrapper for diagnostic messages list."""
+
+    items: List[DiagnosticMessage] = Field(
+        default_factory=list, description="List of diagnostic messages"
+    )
+
+
+class CompletionsResult(BaseModel):
+    """Wrapper for completions list."""
+
+    items: List[CompletionItem] = Field(
+        default_factory=list, description="List of completion items"
+    )
+
+
+class MultiAttemptResult(BaseModel):
+    """Wrapper for multi-attempt results list."""
+
+    items: List[AttemptResult] = Field(
+        default_factory=list, description="List of attempt results"
+    )
+
+
+class LocalSearchResults(BaseModel):
+    """Wrapper for local search results list."""
+
+    items: List[LocalSearchResult] = Field(
+        default_factory=list, description="List of local search results"
+    )
+
+
+class LeanSearchResults(BaseModel):
+    """Wrapper for LeanSearch results list."""
+
+    items: List[LeanSearchResult] = Field(
+        default_factory=list, description="List of LeanSearch results"
+    )
+
+
+class LoogleResults(BaseModel):
+    """Wrapper for Loogle results list."""
+
+    items: List[LoogleResult] = Field(
+        default_factory=list, description="List of Loogle results"
+    )
+
+
+class LeanFinderResults(BaseModel):
+    """Wrapper for Lean Finder results list."""
+
+    items: List[LeanFinderResult] = Field(
+        default_factory=list, description="List of Lean Finder results"
+    )
+
+
+class StateSearchResults(BaseModel):
+    """Wrapper for state search results list."""
+
+    items: List[StateSearchResult] = Field(
+        default_factory=list, description="List of state search results"
+    )
+
+
+class PremiseResults(BaseModel):
+    """Wrapper for premise results list."""
+
+    items: List[PremiseResult] = Field(
+        default_factory=list, description="List of premise results"
+    )

lean_lsp_mcp/search_utils.py

@@ -8,6 +8,7 @@ import platform
 import re
 import shutil
 import subprocess
+import threading
 from orjson import loads as _json_loads
 from pathlib import Path
 
@@ -27,6 +28,21 @@ _PLATFORM_INSTRUCTIONS: dict[str, Iterable[str]] = {
 }
 
 
+def _create_ripgrep_process(command: list[str], *, cwd: str) -> subprocess.Popen[str]:
+    """Spawn ripgrep and return a process with line-streaming stdout.
+
+    Separated for test monkeypatching and to allow early termination once we
+    have enough matches.
+    """
+    return subprocess.Popen(
+        command,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True,
+        cwd=cwd,
+    )
+
+
 def check_ripgrep_status() -> tuple[bool, str]:
     """Check whether ``rg`` is available on PATH and return status + message."""
 
@@ -84,38 +100,116 @@ def lean_local_search(
     if lean_src := _get_lean_src_search_path():
         command.append(lean_src)
 
-    result = subprocess.run(command, capture_output=True, text=True, cwd=str(root))
-
-    matches = []
-    for line in result.stdout.splitlines():
-        if not line or (event := _json_loads(line)).get("type") != "match":
-            continue
+    process = _create_ripgrep_process(command, cwd=str(root))
 
-        data = event["data"]
-        parts = data["lines"]["text"].lstrip().split(maxsplit=2)
-        if len(parts) < 2:
-            continue
-
-        decl_kind, decl_name = parts[0], parts[1].rstrip(":")
-        file_path = Path(data["path"]["text"])
-        abs_path = (
-            file_path if file_path.is_absolute() else (root / file_path).resolve()
-        )
+    matches: list[dict[str, str]] = []
+    stderr_text = ""
+    terminated_early = False
+    stderr_chunks: list[str] = []
+    stderr_chars = 0
+    stderr_truncated = False
+    max_stderr_chars = 100_000
 
+    def _drain_stderr(pipe) -> None:
+        nonlocal stderr_chars, stderr_truncated
         try:
-            display_path = str(abs_path.relative_to(root))
-        except ValueError:
-            display_path = str(file_path)
-
-        matches.append({"name": decl_name, "kind": decl_kind, "file": display_path})
+            for err_line in pipe:
+                if stderr_chars < max_stderr_chars:
+                    stderr_chunks.append(err_line)
+                    stderr_chars += len(err_line)
+                else:
+                    stderr_truncated = True
+        except Exception:
+            return
+
+    stderr_thread: threading.Thread | None = None
+    if process.stderr is not None:
+        stderr_thread = threading.Thread(
+            target=_drain_stderr,
+            args=(process.stderr,),
+            name="lean-local-search-rg-stderr",
+            daemon=True,
+        )
+        stderr_thread.start()
 
-        if len(matches) >= limit:
-            break
+    try:
+        stdout = process.stdout
+        if stdout is None:
+            raise RuntimeError("ripgrep did not provide stdout pipe")
+
+        for line in stdout:
+            if not line or (event := _json_loads(line)).get("type") != "match":
+                continue
+
+            data = event["data"]
+            parts = data["lines"]["text"].lstrip().split(maxsplit=2)
+            if len(parts) < 2:
+                continue
+
+            decl_kind, decl_name = parts[0], parts[1].rstrip(":")
+            file_path = Path(data["path"]["text"])
+            abs_path = (
+                file_path if file_path.is_absolute() else (root / file_path).resolve()
+            )
+
+            try:
+                display_path = str(abs_path.relative_to(root))
+            except ValueError:
+                display_path = str(file_path)
+
+            matches.append({"name": decl_name, "kind": decl_kind, "file": display_path})
+
+            if len(matches) >= limit:
+                terminated_early = True
+                try:
+                    process.terminate()
+                except Exception:
+                    pass
+                break
 
-    if result.returncode not in (0, 1) and not matches:
-        error_msg = f"ripgrep exited with code {result.returncode}"
-        if result.stderr:
-            error_msg += f"\n{result.stderr}"
+        try:
+            if terminated_early:
+                process.wait(timeout=5)
+            else:
+                process.wait()
+        except subprocess.TimeoutExpired:
+            process.kill()
+            process.wait()
+    finally:
+        if process.returncode is None:
+            try:
+                process.terminate()
+            except Exception:
+                pass
+            try:
+                process.wait(timeout=5)
+            except Exception:
+                try:
+                    process.kill()
+                except Exception:
+                    pass
+                try:
+                    process.wait(timeout=5)
+                except Exception:
+                    pass
+        if stderr_thread is not None:
+            stderr_thread.join(timeout=1)
+        if process.stdout is not None:
+            process.stdout.close()
+        if process.stderr is not None:
+            process.stderr.close()
+
+    if stderr_chunks:
+        stderr_text = "".join(stderr_chunks)
+        if stderr_truncated:
+            stderr_text += "\n[stderr truncated]"
+
+    returncode = process.returncode if process.returncode is not None else 0
+
+    if returncode not in (0, 1) and not matches:
+        error_msg = f"ripgrep exited with code {returncode}"
+        if stderr_text:
+            error_msg += f"\n{stderr_text}"
         raise RuntimeError(error_msg)
 
     return matches

lean_lsp_mcp/server.py

@@ -1,79 +1,80 @@
 import asyncio
+import functools
 import os
 import re
 import time
-from typing import Annotated, List, Optional, Dict
-from contextlib import asynccontextmanager
-from collections.abc import AsyncIterator
-from dataclasses import dataclass
 import urllib
-import orjson
-import functools
 import uuid
+from collections.abc import AsyncIterator
+from contextlib import asynccontextmanager
+from dataclasses import dataclass
 from pathlib import Path
+from typing import Annotated, Dict, List, Optional
 
-from pydantic import BaseModel, Field
-from mcp.server.fastmcp import Context, FastMCP
-from mcp.server.fastmcp.utilities.logging import get_logger, configure_logging
+import orjson
+from leanclient import DocumentContentChange, LeanLSPClient
 from mcp.server.auth.settings import AuthSettings
+from mcp.server.fastmcp import Context, FastMCP
+from mcp.server.fastmcp.utilities.logging import configure_logging, get_logger
 from mcp.types import ToolAnnotations
-from leanclient import LeanLSPClient, DocumentContentChange
+from pydantic import Field
 
 from lean_lsp_mcp.client_utils import (
+    infer_project_path,
     setup_client_for_file,
     startup_client,
-    infer_project_path,
 )
 from lean_lsp_mcp.file_utils import get_file_contents
 from lean_lsp_mcp.instructions import INSTRUCTIONS
-from lean_lsp_mcp.search_utils import check_ripgrep_status, lean_local_search
 from lean_lsp_mcp.loogle import LoogleManager, loogle_remote
-from lean_lsp_mcp.outline_utils import generate_outline_data
 from lean_lsp_mcp.models import (
-    LocalSearchResult,
-    LeanSearchResult,
-    LoogleResult,
-    LeanFinderResult,
-    StateSearchResult,
-    PremiseResult,
+    AttemptResult,
+    BuildResult,
+    CompletionItem,
+    CompletionsResult,
+    DeclarationInfo,
     DiagnosticMessage,
+    # Wrapper models for list-returning tools
+    DiagnosticsResult,
+    FileOutline,
     GoalState,
-    CompletionItem,
     HoverInfo,
-    TermGoalState,
-    FileOutline,
-    AttemptResult,
-    BuildResult,
+    LeanFinderResult,
+    LeanFinderResults,
+    LeanSearchResult,
+    LeanSearchResults,
+    LocalSearchResult,
+    LocalSearchResults,
+    LoogleResult,
+    LoogleResults,
+    MultiAttemptResult,
+    PremiseResult,
+    PremiseResults,
     RunResult,
-    DeclarationInfo,
+    StateSearchResult,
+    StateSearchResults,
+    TermGoalState,
 )
+from lean_lsp_mcp.outline_utils import generate_outline_data
+from lean_lsp_mcp.search_utils import check_ripgrep_status, lean_local_search
 from lean_lsp_mcp.utils import (
     COMPLETION_KIND,
+    LeanToolError,
+    OptionalTokenVerifier,
     OutputCapture,
+    check_lsp_response,
     deprecated,
+    extract_goals_list,
     extract_range,
     filter_diagnostics_by_position,
     find_start_position,
-    format_goal,
     get_declaration_range,
-    OptionalTokenVerifier,
 )
 
 # LSP Diagnostic severity: 1=error, 2=warning, 3=info, 4=hint
 DIAGNOSTIC_SEVERITY: Dict[int, str] = {1: "error", 2: "warning", 3: "info", 4: "hint"}
 
 
-class LeanToolError(Exception):
-    pass
-
-
-def _to_json_array(items: List[BaseModel]) -> str:
-    """Serialize list of models as JSON array (avoids FastMCP list flattening)."""
-    return orjson.dumps(
-        [item.model_dump() for item in items], option=orjson.OPT_INDENT_2
-    ).decode()
-
-
 _LOG_LEVEL = os.environ.get("LEAN_LOG_LEVEL", "INFO")
 configure_logging("CRITICAL" if _LOG_LEVEL == "NONE" else _LOG_LEVEL)
 logger = get_logger(__name__)
@@ -107,7 +108,7 @@ async def app_lifespan(server: FastMCP) -> AsyncIterator[AppContext]:
         # Initialize local loogle if enabled via env var or CLI
         if os.environ.get("LEAN_LOOGLE_LOCAL", "").lower() in ("1", "true", "yes"):
             logger.info("Local loogle enabled, initializing...")
-            loogle_manager = LoogleManager()
+            loogle_manager = LoogleManager(project_path=lean_project_path)
             if loogle_manager.ensure_installed():
                 if await loogle_manager.start():
                     loogle_local_available = True
@@ -414,7 +415,7 @@ def diagnostic_messages(
     declaration_name: Annotated[
         Optional[str], Field(description="Filter to declaration (slow)")
     ] = None,
-) -> str:
+) -> DiagnosticsResult:
     """Get compiler diagnostics (errors, warnings, infos) for a Lean file."""
     rel_path = setup_client_for_file(ctx, file_path)
     if not rel_path:
@@ -442,8 +443,9 @@ def diagnostic_messages(
         end_line=end_line_0,
         inactivity_timeout=15.0,
     )
+    check_lsp_response(diagnostics, "get_diagnostics")
 
-    return _to_json_array(_to_diagnostic_messages(diagnostics))
+    return DiagnosticsResult(items=_to_diagnostic_messages(diagnostics))
 
 
 @mcp.tool(
@@ -491,15 +493,18 @@ def goal(
             (i for i, c in enumerate(line_context) if not c.isspace()), 0
         )
         goal_start = client.get_goal(rel_path, line - 1, column_start)
+        check_lsp_response(goal_start, "get_goal", allow_none=True)
         goal_end = client.get_goal(rel_path, line - 1, column_end)
-        before = format_goal(goal_start, None)
-        after = format_goal(goal_end, None)
-        goals = f"{before} → {after}" if before != after else after
-        return GoalState(line_context=line_context, goals=goals)
+        return GoalState(
+            line_context=line_context,
+            goals_before=extract_goals_list(goal_start),
+            goals_after=extract_goals_list(goal_end),
+        )
     else:
         goal_result = client.get_goal(rel_path, line - 1, column - 1)
+        check_lsp_response(goal_result, "get_goal", allow_none=True)
         return GoalState(
-            line_context=line_context, goals=format_goal(goal_result, None)
+            line_context=line_context, goals=extract_goals_list(goal_result)
         )
 
 
@@ -540,6 +545,7 @@ def term_goal(
         column = len(line_context)
 
     term_goal_result = client.get_term_goal(rel_path, line - 1, column - 1)
+    check_lsp_response(term_goal_result, "get_term_goal", allow_none=True)
     expected_type = None
     if term_goal_result is not None:
         rendered = term_goal_result.get("goal")
@@ -575,6 +581,7 @@ def hover(
     client.open_file(rel_path)
     file_content = client.get_file_content(rel_path)
     hover_info = client.get_hover(rel_path, line - 1, column - 1)
+    check_lsp_response(hover_info, "get_hover", allow_none=True)
     if hover_info is None:
         raise LeanToolError(f"No hover information at line {line}, column {column}")
 
@@ -586,6 +593,7 @@ def hover(
 
     # Add diagnostics if available
     diagnostics = client.get_diagnostics(rel_path)
+    check_lsp_response(diagnostics, "get_diagnostics")
     filtered = filter_diagnostics_by_position(diagnostics, line - 1, column - 1)
 
     return HoverInfo(
@@ -610,7 +618,7 @@ def completions(
     line: Annotated[int, Field(description="Line number (1-indexed)", ge=1)],
     column: Annotated[int, Field(description="Column number (1-indexed)", ge=1)],
     max_completions: Annotated[int, Field(description="Max completions", ge=1)] = 32,
-) -> str:
+) -> CompletionsResult:
     """Get IDE autocompletions. Use on INCOMPLETE code (after `.` or partial name)."""
     rel_path = setup_client_for_file(ctx, file_path)
     if not rel_path:
@@ -622,6 +630,7 @@ def completions(
     client.open_file(rel_path)
     content = client.get_file_content(rel_path)
     raw_completions = client.get_completions(rel_path, line - 1, column - 1)
+    check_lsp_response(raw_completions, "get_completions")
 
     # Convert to CompletionItem models
     items: List[CompletionItem] = []
@@ -639,7 +648,7 @@ def completions(
         )
 
     if not items:
-        return "[]"
+        return CompletionsResult(items=[])
 
     # Find the sort term: The last word/identifier before the cursor
     lines = content.splitlines()
@@ -666,7 +675,7 @@ def completions(
         items.sort(key=lambda x: x.label.lower())
 
     # Truncate if too many results
-    return _to_json_array(items[:max_completions])
+    return CompletionsResult(items=items[:max_completions])
 
 
 @mcp.tool(
@@ -741,7 +750,7 @@ def multi_attempt(
     snippets: Annotated[
         List[str], Field(description="Tactics to try (3+ recommended)")
     ],
-) -> str:
+) -> MultiAttemptResult:
     """Try multiple tactics without modifying file. Returns goal state for each."""
     rel_path = setup_client_for_file(ctx, file_path)
     if not rel_path:
@@ -753,8 +762,6 @@ def multi_attempt(
     client.open_file(rel_path)
 
     try:
-        client.open_file(rel_path)
-
         results: List[AttemptResult] = []
         # Avoid mutating caller-provided snippets; normalize locally per attempt
         for snippet in snippets:
@@ -769,19 +776,20 @@ def multi_attempt(
             # Apply the change to the file, capture diagnostics and goal state
             client.update_file(rel_path, [change])
             diag = client.get_diagnostics(rel_path)
+            check_lsp_response(diag, "get_diagnostics")
             filtered_diag = filter_diagnostics_by_position(diag, line - 1, None)
             # Use the snippet text length without any trailing newline for the column
             goal_result = client.get_goal(rel_path, line - 1, len(snippet_str))
-            goal_state = format_goal(goal_result, None)
+            goals = extract_goals_list(goal_result)
             results.append(
                 AttemptResult(
                     snippet=snippet_str,
-                    goal_state=goal_state,
+                    goals=goals,
                     diagnostics=_to_diagnostic_messages(filtered_diag),
                 )
             )
 
-        return _to_json_array(results)
+        return MultiAttemptResult(items=results)
     finally:
         try:
             client.close_files([rel_path])
@@ -837,6 +845,7 @@ def run_code(
         client.open_file(rel_path)
         opened_file = True
         raw_diagnostics = client.get_diagnostics(rel_path, inactivity_timeout=15.0)
+        check_lsp_response(raw_diagnostics, "get_diagnostics")
     finally:
         if opened_file:
             try:
@@ -878,7 +887,7 @@ def local_search(
     project_root: Annotated[
         Optional[str], Field(description="Project root (inferred if omitted)")
     ] = None,
-) -> str:
+) -> LocalSearchResults:
     """Fast local search to verify declarations exist. Use BEFORE trying a lemma name."""
     if not _RG_AVAILABLE:
         raise LocalSearchError(_RG_MESSAGE)
@@ -910,7 +919,7 @@ def local_search(
             LocalSearchResult(name=r["name"], kind=r["kind"], file=r["file"])
             for r in raw_results
         ]
-        return _to_json_array(results)
+        return LocalSearchResults(items=results)
     except RuntimeError as exc:
         raise LocalSearchError(f"Search failed: {exc}")
 
@@ -929,7 +938,7 @@ def leansearch(
     ctx: Context,
     query: Annotated[str, Field(description="Natural language or Lean term query")],
     num_results: Annotated[int, Field(description="Max results", ge=1)] = 5,
-) -> str:
+) -> LeanSearchResults:
     """Search Mathlib via leansearch.net using natural language.
 
     Examples: "sum of two even numbers is even", "Cauchy-Schwarz inequality",
@@ -945,11 +954,11 @@ def leansearch(
         method="POST",
     )
 
-    with urllib.request.urlopen(req, timeout=20) as response:
+    with urllib.request.urlopen(req, timeout=10) as response:
         results = orjson.loads(response.read())
 
     if not results or not results[0]:
-        return "[]"
+        return LeanSearchResults(items=[])
 
     raw_results = [r["result"] for r in results[0][:num_results]]
     items = [
@@ -961,7 +970,7 @@ def leansearch(
         )
         for r in raw_results
     ]
-    return _to_json_array(items)
+    return LeanSearchResults(items=items)
 
 
 @mcp.tool(
@@ -979,7 +988,7 @@ async def loogle(
         str, Field(description="Type pattern, constant, or name substring")
     ],
     num_results: Annotated[int, Field(description="Max results", ge=1)] = 8,
-) -> str:
+) -> LoogleResults:
     """Search Mathlib by type signature via loogle.lean-lang.org.
 
     Examples: `Real.sin`, `"comm"`, `(?a → ?b) → List ?a → List ?b`,
@@ -989,10 +998,15 @@ async def loogle(
 
     # Try local loogle first if available (no rate limiting)
     if app_ctx.loogle_local_available and app_ctx.loogle_manager:
+        # Update project path if it changed (adds new library paths)
+        if app_ctx.lean_project_path != app_ctx.loogle_manager.project_path:
+            if app_ctx.loogle_manager.set_project_path(app_ctx.lean_project_path):
+                # Restart to pick up new paths
+                await app_ctx.loogle_manager.stop()
         try:
             results = await app_ctx.loogle_manager.query(query, num_results)
             if not results:
-                return "No results found."
+                return LoogleResults(items=[])
             items = [
                 LoogleResult(
                     name=r.get("name", ""),
@@ -1001,7 +1015,7 @@ async def loogle(
                 )
                 for r in results
             ]
-            return _to_json_array(items)
+            return LoogleResults(items=items)
         except Exception as e:
             logger.warning(f"Local loogle failed: {e}, falling back to remote")
 
@@ -1010,13 +1024,15 @@ async def loogle(
     now = int(time.time())
     rate_limit[:] = [t for t in rate_limit if now - t < 30]
     if len(rate_limit) >= 3:
-        return "Rate limit exceeded: 3 requests per 30s. Use --loogle-local to avoid limits."
+        raise LeanToolError(
+            "Rate limit exceeded: 3 requests per 30s. Use --loogle-local to avoid limits."
+        )
     rate_limit.append(now)
 
     result = loogle_remote(query, num_results)
     if isinstance(result, str):
-        return result  # Error message
-    return _to_json_array(result)
+        raise LeanToolError(result)  # Error message from remote
+    return LoogleResults(items=result)
 
 
 @mcp.tool(
@@ -1033,7 +1049,7 @@ def leanfinder(
     ctx: Context,
     query: Annotated[str, Field(description="Mathematical concept or proof state")],
     num_results: Annotated[int, Field(description="Max results", ge=1)] = 5,
-) -> str:
+) -> LeanFinderResults:
     """Semantic search by mathematical meaning via Lean Finder.
 
     Examples: "commutativity of addition on natural numbers",
@@ -1047,7 +1063,7 @@ def leanfinder(
     )
 
     results: List[LeanFinderResult] = []
-    with urllib.request.urlopen(req, timeout=30) as response:
+    with urllib.request.urlopen(req, timeout=10) as response:
         data = orjson.loads(response.read())
         for result in data["results"]:
             if (
@@ -1065,7 +1081,7 @@ def leanfinder(
                     )
                 )
 
-    return _to_json_array(results)
+    return LeanFinderResults(items=results)
 
 
 @mcp.tool(
@@ -1084,7 +1100,7 @@ def state_search(
     line: Annotated[int, Field(description="Line number (1-indexed)", ge=1)],
     column: Annotated[int, Field(description="Column number (1-indexed)", ge=1)],
     num_results: Annotated[int, Field(description="Max results", ge=1)] = 5,
-) -> str:
+) -> StateSearchResults:
     """Find lemmas to close the goal at a position. Searches premise-search.com."""
     rel_path = setup_client_for_file(ctx, file_path)
     if not rel_path:
@@ -1110,11 +1126,11 @@ def state_search(
         method="GET",
     )
 
-    with urllib.request.urlopen(req, timeout=20) as response:
+    with urllib.request.urlopen(req, timeout=10) as response:
         results = orjson.loads(response.read())
 
     items = [StateSearchResult(name=r["name"]) for r in results]
-    return _to_json_array(items)
+    return StateSearchResults(items=items)
 
 
 @mcp.tool(
@@ -1133,7 +1149,7 @@ def hammer_premise(
     line: Annotated[int, Field(description="Line number (1-indexed)", ge=1)],
     column: Annotated[int, Field(description="Column number (1-indexed)", ge=1)],
     num_results: Annotated[int, Field(description="Max results", ge=1)] = 32,
-) -> str:
+) -> PremiseResults:
     """Get premise suggestions for automation tactics at a goal position.
 
     Returns lemma names to try with `simp only [...]`, `aesop`, or as hints.
@@ -1170,11 +1186,11 @@ def hammer_premise(
         data=orjson.dumps(data),
     )
 
-    with urllib.request.urlopen(req, timeout=20) as response:
+    with urllib.request.urlopen(req, timeout=10) as response:
         results = orjson.loads(response.read())
 
     items = [PremiseResult(name=r["name"]) for r in results]
-    return _to_json_array(items)
+    return PremiseResults(items=items)
 
 
 if __name__ == "__main__":

lean_lsp_mcp/utils.py

@@ -2,11 +2,39 @@ import os
 import secrets
 import sys
 import tempfile
-from typing import List, Dict, Optional, Callable
+from typing import Any, List, Dict, Optional, Callable
 
 from mcp.server.auth.provider import AccessToken, TokenVerifier
 
 
+class LeanToolError(Exception):
+    """Exception raised when a Lean MCP tool operation fails."""
+
+    pass
+
+
+def check_lsp_response(
+    response: Any, operation: str, *, allow_none: bool = False
+) -> Any:
+    """Check an LSP response for error patterns and raise if found.
+
+    Args:
+        response: The response from a leanclient LSP operation
+        operation: Human-readable description of the operation
+        allow_none: If False (default), None raises LeanToolError (timeout).
+                    If True, None is allowed (for operations where None is valid).
+
+    Raises:
+        LeanToolError: If response indicates failure
+    """
+    if response is None and not allow_none:
+        raise LeanToolError(f"LSP timeout during {operation}")
+    if isinstance(response, dict) and "error" in response:
+        msg = response["error"].get("message", "unknown error")
+        raise LeanToolError(f"LSP error during {operation}: {msg}")
+    return response
+
+
 class OutputCapture:
     """Capture any output to stdout and stderr at the file descriptor level."""
 
@@ -80,11 +108,11 @@ def format_diagnostics(diagnostics: List[Dict], select_line: int = -1) -> List[s
     return msgs
 
 
-def format_goal(goal, default_msg):
-    if goal is None:
-        return default_msg
-    rendered = goal.get("rendered")
-    return rendered.replace("```lean\n", "").replace("\n```", "") if rendered else None
+def extract_goals_list(goal_response: dict | None) -> List[str]:
+    """Extract goals list from LSP response, returning empty list if no goals."""
+    if goal_response is None:
+        return []
+    return goal_response.get("goals", [])
 
 
 def _utf16_index_to_py_index(text: str, utf16_index: int) -> int | None:

{lean_lsp_mcp-0.16.1.dist-info → lean_lsp_mcp-0.17.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lean-lsp-mcp
-Version: 0.16.1
+Version: 0.17.0
 Summary: Lean Theorem Prover MCP
 Author-email: Oliver Dressler <hey@oli.show>
 License-Expression: MIT
@@ -8,9 +8,8 @@ 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.6.1
-Requires-Dist: mcp[cli]==1.23.1
-Requires-Dist: mcp[cli]>=1.22.0
+Requires-Dist: leanclient==0.7.0
+Requires-Dist: mcp[cli]==1.24.0
 Requires-Dist: orjson>=3.11.1
 Provides-Extra: lint
 Requires-Dist: ruff>=0.2.0; extra == "lint"

lean_lsp_mcp-0.17.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+lean_lsp_mcp/__init__.py,sha256=MN_bNFyb5-p33JWWGbrlUYBd1UUMQKtZYGC9KCh2mtM,1403
+lean_lsp_mcp/__main__.py,sha256=XnpTzfJc0T-j9tHtdkA8ovTr1c139ffTewcJGhxYDaM,49
+lean_lsp_mcp/client_utils.py,sha256=HgPuB35rMitn2Xm8SCAErsFLq15trB6VMz3FDFgmPd8,4897
+lean_lsp_mcp/file_utils.py,sha256=kCTYQSfmV-R2cm_NCi_L8W5Dcsm0_rTOPpTtpyAin78,1365
+lean_lsp_mcp/instructions.py,sha256=iJk_oD67tqNaC8K5OXEuXafULKSbbiHjZAsSRebOwdw,1904
+lean_lsp_mcp/loogle.py,sha256=zUgnDWoTIqa4G6GXStAIxxJUR545YbU8Z-8KMjddKV0,15500
+lean_lsp_mcp/models.py,sha256=2pLmvNsrMdn4vO1k119Jw8gqYeaeGKewWW0q1TabBCY,6604
+lean_lsp_mcp/outline_utils.py,sha256=-eoZNbx2eaKaYmuyFJnwUMWP8I9YXNWusue_2OYpDBM,10981
+lean_lsp_mcp/search_utils.py,sha256=MLqKGe4bhEvyfFLIBCmiDxkbcH4O5J3vl9mWnRSb_v0,6801
+lean_lsp_mcp/server.py,sha256=1G7-FZz1TNJ7uU36eSTm9yponWyMO3QhQiyOhhTNOH8,40626
+lean_lsp_mcp/utils.py,sha256=MmGgdhrLEvCtRRVNgN_vflO9_A25h76QbJXhBD-OKt0,12721
+lean_lsp_mcp-0.17.0.dist-info/licenses/LICENSE,sha256=CQlxnf0tQyoVrBE93JYvAUYxv6Z5Yg6sX0pwogOkFvo,1071
+lean_lsp_mcp-0.17.0.dist-info/METADATA,sha256=W23YEfDLfEd_C7YdjynKhmyId5wSYfqdoZ8CyVoeCzo,20787
+lean_lsp_mcp-0.17.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lean_lsp_mcp-0.17.0.dist-info/entry_points.txt,sha256=nQbvwctWkWD7I-2f4VrdVQBZYGUw8CnUnFC6QjXxOSE,51
+lean_lsp_mcp-0.17.0.dist-info/top_level.txt,sha256=LGEK0lgMSNPIQ6mG8EO-adaZEGPi_0daDs004epOTF0,13
+lean_lsp_mcp-0.17.0.dist-info/RECORD,,

lean_lsp_mcp-0.16.1.dist-info/RECORD

@@ -1,17 +0,0 @@
-lean_lsp_mcp/__init__.py,sha256=MN_bNFyb5-p33JWWGbrlUYBd1UUMQKtZYGC9KCh2mtM,1403
-lean_lsp_mcp/__main__.py,sha256=XnpTzfJc0T-j9tHtdkA8ovTr1c139ffTewcJGhxYDaM,49
-lean_lsp_mcp/client_utils.py,sha256=HgPuB35rMitn2Xm8SCAErsFLq15trB6VMz3FDFgmPd8,4897
-lean_lsp_mcp/file_utils.py,sha256=kCTYQSfmV-R2cm_NCi_L8W5Dcsm0_rTOPpTtpyAin78,1365
-lean_lsp_mcp/instructions.py,sha256=S1y834V8v-SFSYJlxxy6Dj-Z0szMyEBT5SkEyM6Npr8,1756
-lean_lsp_mcp/loogle.py,sha256=ChybtPM8jOxP8s28358yNqcLiYvGlQqkAEFFLzR87Zw,11971
-lean_lsp_mcp/models.py,sha256=M8CmTg0_NL7KwcQ7UX_Zk7ZG1zXoWLINr41NPs_no2Y,4301
-lean_lsp_mcp/outline_utils.py,sha256=-eoZNbx2eaKaYmuyFJnwUMWP8I9YXNWusue_2OYpDBM,10981
-lean_lsp_mcp/search_utils.py,sha256=X2LPynDNLi767UDxbxHpMccOkbnfKJKv_HxvRNxIXM4,3984
-lean_lsp_mcp/server.py,sha256=8QEkRlbLEKif4NfagD2l1min1w1IFF7Jw1TUUOK-xFg,39481
-lean_lsp_mcp/utils.py,sha256=355kzyB3dkwU7_4Mfcg--JXEorFaE2gtqs6-HbH5rRE,11722
-lean_lsp_mcp-0.16.1.dist-info/licenses/LICENSE,sha256=CQlxnf0tQyoVrBE93JYvAUYxv6Z5Yg6sX0pwogOkFvo,1071
-lean_lsp_mcp-0.16.1.dist-info/METADATA,sha256=nwfjUYlagiUb49IkT3AWoOmJwH4fnwJ5ElyvD9V8zGw,20819
-lean_lsp_mcp-0.16.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lean_lsp_mcp-0.16.1.dist-info/entry_points.txt,sha256=nQbvwctWkWD7I-2f4VrdVQBZYGUw8CnUnFC6QjXxOSE,51
-lean_lsp_mcp-0.16.1.dist-info/top_level.txt,sha256=LGEK0lgMSNPIQ6mG8EO-adaZEGPi_0daDs004epOTF0,13
-lean_lsp_mcp-0.16.1.dist-info/RECORD,,