hedit 0.7.9.dev4__tar.gz → 0.7.10a2__tar.gz

{hedit-0.7.9.dev4/hedit.egg-info → hedit-0.7.10a2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hedit
-Version: 0.7.9.dev4
+Version: 0.7.10a2
 Summary: Multi-agent system for HED annotation generation and validation
 Author-email: Annotation Garden Initiative <info@annotation.garden>
 License-Expression: MIT

{hedit-0.7.9.dev4 → hedit-0.7.10a2/hedit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hedit
-Version: 0.7.9.dev4
+Version: 0.7.10a2
 Summary: Multi-agent system for HED annotation generation and validation
 Author-email: Annotation Garden Initiative <info@annotation.garden>
 License-Expression: MIT

{hedit-0.7.9.dev4 → hedit-0.7.10a2}/hedit.egg-info/SOURCES.txt

@@ -33,10 +33,15 @@ src/cli/local_executor.py
 src/cli/main.py
 src/cli/output.py
 src/cli/commands/__init__.py
+src/cli/commands/lsp.py
 src/data/__init__.py
 src/data/hed-docs/02_Terminology.md
 src/data/hed-docs/HedAnnotationSemantics.md
 src/data/hed-docs/manifest.json
+src/lsp/__init__.py
+src/lsp/client.py
+src/lsp/daemon.py
+src/lsp/protocol.py
 src/scripts/__init__.py
 src/scripts/process_feedback.py
 src/telemetry/__init__.py
@@ -69,10 +74,8 @@ tests/test_feedback_triage.py
 tests/test_fetch_hed_docs.py
 tests/test_github_client.py
 tests/test_hed_docs_loader.py
-tests/test_hed_lsp.py
 tests/test_integration_openrouter.py
 tests/test_json_schema_loader.py
-tests/test_keyword_extraction.py
 tests/test_litellm_llm.py
 tests/test_no_extend_propagation.py
 tests/test_openrouter_llm.py

{hedit-0.7.9.dev4 → hedit-0.7.10a2}/hedit.egg-info/entry_points.txt

@@ -1,2 +1,3 @@
 [console_scripts]
 hedit = src.cli.main:cli
+hedit-lspd = src.lsp.daemon:main

{hedit-0.7.9.dev4 → hedit-0.7.10a2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "hedit"
-version = "0.7.9.dev4"
+version = "0.7.10a2"
 description = "Multi-agent system for HED annotation generation and validation"
 readme = "PKG_README.md"
 requires-python = ">=3.12"
@@ -39,6 +39,7 @@ dependencies = [
 
 [project.scripts]
 hedit = "src.cli.main:cli"
+hedit-lspd = "src.lsp.daemon:main"
 
 [project.urls]
 Homepage = "https://annotation.garden/hedit"

{hedit-0.7.9.dev4 → hedit-0.7.10a2}/src/agents/validation_agent.py

@@ -12,9 +12,9 @@ import re
 from pathlib import Path
 
 from src.agents.state import HedAnnotationState
+from src.lsp import HedLspClient
 from src.utils.error_remediation import get_remediator
 from src.utils.schema_loader import HedSchemaLoader
-from src.validation.hed_lsp import is_hed_lsp_available, suggest_tags_for_keywords
 from src.validation.hed_validator import (
     HedJavaScriptValidator,
     HedPythonValidator,
@@ -81,7 +81,7 @@ class ValidationAgent:
         use_javascript: bool = True,
         validator_path: Path | None = None,
         tests_json_path: Path | str | None = None,
-        use_hed_lsp: bool = True,
+        lsp_client: HedLspClient | None = None,
     ) -> None:
         """Initialize the validation agent.
 
@@ -90,13 +90,14 @@ class ValidationAgent:
             use_javascript: Whether to use JavaScript validator (more detailed)
             validator_path: Path to hed-javascript repository (required if use_javascript=True)
             tests_json_path: Optional path to javascriptTests.json for error remediation
-            use_hed_lsp: Whether to use hed-lsp for tag suggestions (auto-detected)
+            lsp_client: Pre-built HedLspClient for tag-replacement suggestions
+                when validation finds invalid tags. None disables suggestions.
         """
         self.schema_loader = schema_loader
         self.use_javascript = use_javascript
         self.validator_path = validator_path
         self.error_remediator = get_remediator(tests_json_path)
-        self.use_hed_lsp = use_hed_lsp and is_hed_lsp_available()
+        self.lsp_client = lsp_client
 
         # Validator is lazily initialized on first use via _get_or_create_validator
         self._validator: HedJavaScriptValidator | HedPythonValidator | None = None
@@ -134,34 +135,37 @@ class ValidationAgent:
 
         return problematic_tags
 
-    def _get_tag_suggestions(
-        self, problematic_tags: list[str], schema_version: str
-    ) -> dict[str, list[str]]:
-        """Get suggested valid tags for problematic tags using hed-lsp.
+    async def _get_tag_suggestions(self, problematic_tags: list[str]) -> dict[str, list[str]]:
+        """Get suggested valid tags for problematic tags via persistent LSP.
 
         Args:
             problematic_tags: List of problematic tag names
-            schema_version: HED schema version
 
         Returns:
-            Dictionary mapping problematic tags to suggested alternatives
+            Dictionary mapping each problematic tag to a list of suggested
+            valid alternatives. Empty if no LSP client is configured or the
+            server returned no matches.
         """
-        if not self.use_hed_lsp or not problematic_tags:
+        if self.lsp_client is None or not problematic_tags:
             return {}
 
         try:
-            return suggest_tags_for_keywords(
-                problematic_tags,
-                schema_version=schema_version,
-                max_results=5,  # Limit suggestions for clarity
-            )
-        except (RuntimeError, OSError) as e:
+            result = await self.lsp_client.suggest(*problematic_tags)
+        except Exception as exc:
+            # `suggest()` already converts transport errors to a failure
+            # result; anything that lands here is a programming error and
+            # deserves a traceback.
             logger.warning(
-                "Failed to get tag suggestions from hed-lsp for tags %s: %s",
+                "hed-lsp suggest call failed for tags %s: %s",
                 problematic_tags,
-                e,
+                exc,
+                exc_info=True,
             )
             return {}
+        if not result.success:
+            logger.debug("hed-lsp suggest returned failure: %s", result.error)
+            return {}
+        return result.raw
 
     async def validate(self, state: HedAnnotationState) -> dict:
         """Validate the current HED annotation.
@@ -202,10 +206,10 @@ class ValidationAgent:
 
         # Extract problematic tags and get suggestions from hed-lsp
         tag_suggestions: dict[str, list[str]] = {}
-        if not result.is_valid and self.use_hed_lsp:
+        if not result.is_valid and self.lsp_client is not None:
             problematic_tags = self._extract_problematic_tags(result.errors, result.warnings)
             if problematic_tags:
-                tag_suggestions = self._get_tag_suggestions(problematic_tags, schema_version)
+                tag_suggestions = await self._get_tag_suggestions(problematic_tags)
 
         # Determine validation status
         validation_attempts = state["validation_attempts"] + 1

{hedit-0.7.9.dev4 → hedit-0.7.10a2}/src/agents/workflow.py

@@ -4,7 +4,6 @@ This module defines the multi-agent workflow that orchestrates
 annotation, validation, evaluation, and assessment.
 """
 
-import asyncio
 import logging
 import time
 from pathlib import Path
@@ -19,9 +18,9 @@ from src.agents.evaluation_agent import EvaluationAgent
 from src.agents.feedback_summarizer import FeedbackSummarizer
 from src.agents.state import HedAnnotationState
 from src.agents.validation_agent import ValidationAgent
+from src.lsp import HedLspClient
 from src.utils import extract_text_content
 from src.utils.schema_loader import HedSchemaLoader
-from src.validation.hed_lsp import HedLspClient, is_hed_lsp_available
 
 logger = logging.getLogger(__name__)
 
@@ -47,10 +46,12 @@ class HedAnnotationWorkflow:
         evaluation_llm: BaseChatModel | None = None,
         assessment_llm: BaseChatModel | None = None,
         feedback_llm: BaseChatModel | None = None,
+        keyword_llm: BaseChatModel | None = None,
         schema_dir: Path | str | None = None,
         validator_path: Path | None = None,
         use_js_validator: bool = True,
         enable_semantic_search: bool = True,
+        lsp_client: HedLspClient | None = None,
     ) -> None:
         """Initialize the workflow.
 
@@ -59,15 +60,28 @@ class HedAnnotationWorkflow:
             evaluation_llm: Language model for evaluation agent (defaults to llm)
             assessment_llm: Language model for assessment agent (defaults to llm)
             feedback_llm: Language model for feedback summarization (defaults to llm)
+            keyword_llm: Lightweight LLM for keyword extraction inside
+                ``_semantic_preprocess_node``. Defaults to ``llm`` (the
+                annotation LLM, typically a fast model like claude-haiku
+                with reasoning disabled). Previously this task piggy-backed
+                on ``feedback_llm`` which in prod is wired to the heavier
+                evaluation model — a five-keyword extraction does not
+                need a 35B-parameter model with extended reasoning.
             schema_dir: Directory containing JSON schemas
             validator_path: Path to hed-javascript for validation
             use_js_validator: Whether to use JavaScript validator
-            enable_semantic_search: Whether to use hed-lsp CLI for tag suggestions
+            enable_semantic_search: Whether to include the semantic_preprocess
+                node in the graph. The node is only useful when an
+                `lsp_client` is also provided.
+            lsp_client: Pre-built, already-initialized HedLspClient. The
+                caller (FastAPI lifespan, CLI executor) owns the client's
+                lifetime. None disables LSP-backed tag enrichment.
         """
         # Store schema directory (None means use HED library to fetch from GitHub)
         self.schema_dir = schema_dir
-        # Keyword extraction always runs; LSP enrichment requires hed-lsp CLI
+        # Keyword extraction always runs; LSP enrichment requires an injected client
         self.enable_semantic_search = enable_semantic_search
+        self.lsp_client: HedLspClient | None = lsp_client
 
         # Initialize legacy schema loader for validation
         self.schema_loader = HedSchemaLoader()
@@ -76,9 +90,12 @@ class HedAnnotationWorkflow:
         eval_llm = evaluation_llm or llm
         assess_llm = assessment_llm or llm
         feed_llm = feedback_llm or llm
+        kw_llm = keyword_llm or llm
 
-        # Store feedback LLM for keyword extraction (cheap/fast model)
-        self.feedback_llm = feed_llm
+        # Keyword extraction uses a dedicated lightweight model
+        # (defaults to the annotation LLM, which is typically fast +
+        # reasoning-disabled for this short structured task).
+        self.keyword_llm = kw_llm
 
         # Initialize agents with JSON schema support and per-agent LLMs
         self.annotation_agent = AnnotationAgent(llm, schema_dir=self.schema_dir)
@@ -86,22 +103,17 @@ class HedAnnotationWorkflow:
             self.schema_loader,
             use_javascript=use_js_validator,
             validator_path=validator_path,
+            lsp_client=self.lsp_client,
         )
         self.evaluation_agent = EvaluationAgent(eval_llm, schema_dir=self.schema_dir)
         self.assessment_agent = AssessmentAgent(assess_llm, schema_dir=self.schema_dir)
         self.feedback_summarizer = FeedbackSummarizer(feed_llm)
 
-        # Initialize hed-lsp client for semantic search (optional enrichment)
-        self.hed_lsp_client: HedLspClient | None = None
-        if self.enable_semantic_search and is_hed_lsp_available():
-            try:
-                self.hed_lsp_client = HedLspClient()
-                logger.info("[WORKFLOW] hed-lsp CLI available for semantic tag suggestions")
-            except RuntimeError as e:
-                logger.warning(f"[WORKFLOW] hed-lsp CLI not available: {e}")
+        if self.enable_semantic_search and self.lsp_client is not None:
+            logger.info("[WORKFLOW] hed-lsp client connected for semantic tag suggestions")
         elif self.enable_semantic_search:
             logger.info(
-                "[WORKFLOW] hed-lsp CLI not in PATH; "
+                "[WORKFLOW] semantic_preprocess enabled but no lsp_client provided; "
                 "keyword extraction will run without LSP enrichment"
             )
 
@@ -195,7 +207,7 @@ class HedAnnotationWorkflow:
         )
 
         try:
-            response = await self.feedback_llm.ainvoke(
+            response = await self.keyword_llm.ainvoke(
                 [
                     SystemMessage(content=system_prompt),
                     HumanMessage(content=f"Description: {description}"),
@@ -236,52 +248,46 @@ class HedAnnotationWorkflow:
         # Step 1: Extract keywords from the description using LLM
         keywords = await self._extract_keywords(state["input_description"])
 
-        # Step 2: Use hed-lsp CLI to get tag suggestions for each keyword
+        # Step 2: One batched hed/suggest call over the persistent LSP
+        # connection. The previous per-keyword loop spawned the hed-suggest
+        # CLI once per keyword and dominated request latency (~6 s/spawn).
         semantic_hints: list[dict] = []
 
-        if keywords and self.hed_lsp_client:
-            # Query hed-lsp for each keyword individually for better results
-            for keyword in keywords:
-                try:
-                    result = await asyncio.to_thread(self.hed_lsp_client.suggest, keyword)
-                except Exception as e:
-                    logger.warning("[WORKFLOW] hed-lsp error for '%s': %s", keyword, e)
-                    continue
-                if result.success:
-                    for s in result.suggestions:
-                        semantic_hints.append(
-                            {
-                                "tag": s.tag,
+        if keywords and self.lsp_client is not None:
+            try:
+                result = await self.lsp_client.suggest(*keywords)
+            except Exception as e:
+                # `suggest()` already swallows transport errors and returns a
+                # failure result; anything that reaches here is unexpected
+                # and deserves a full traceback in logs.
+                logger.warning("[WORKFLOW] hed-lsp suggest failed: %s", e, exc_info=True)
+                result = None
+
+            if result is not None and result.success:
+                seen_tags: dict[str, dict] = {}
+                for keyword, tags in result.raw.items():
+                    for idx, tag in enumerate(tags):
+                        # Higher score for earlier (more relevant) hits.
+                        score = max(0.0, 1.0 - idx * 0.05)
+                        existing = seen_tags.get(tag)
+                        if existing is None or score > existing["score"]:
+                            seen_tags[tag] = {
+                                "tag": tag,
                                 "keyword": keyword,
-                                "score": s.score or 0.0,
+                                "score": score,
                                 "source": "hed-lsp",
                             }
-                        )
-                else:
-                    logger.debug(
-                        "[WORKFLOW] hed-lsp suggestion failed for '%s': %s",
-                        keyword,
-                        result.error,
-                    )
-
-            # Deduplicate by tag, keeping highest score
-            if semantic_hints:
-                seen_tags: dict[str, dict] = {}
-                for hint in semantic_hints:
-                    tag = hint["tag"]
-                    if tag not in seen_tags or hint["score"] > seen_tags[tag]["score"]:
-                        seen_tags[tag] = hint
                 semantic_hints = sorted(seen_tags.values(), key=lambda h: h["score"], reverse=True)
-
-            logger.info(
-                "[WORKFLOW] hed-lsp suggested %d unique tags from %d keywords",
-                len(semantic_hints),
-                len(keywords),
-            )
+                logger.info(
+                    "[WORKFLOW] hed-lsp suggested %d unique tags from %d keywords",
+                    len(semantic_hints),
+                    len(keywords),
+                )
+            elif result is not None:
+                logger.debug("[WORKFLOW] hed-lsp suggest returned failure: %s", result.error)
         elif keywords:
-            # LSP not available; still store keywords for the annotation agent
             logger.info(
-                "[WORKFLOW] hed-lsp not available; storing %d extracted keywords",
+                "[WORKFLOW] no lsp_client; storing %d extracted keywords without enrichment",
                 len(keywords),
             )
 

{hedit-0.7.9.dev4 → hedit-0.7.10a2}/src/api/main.py

@@ -35,6 +35,7 @@ from src.api.models import (
     ValidationResponse,
 )
 from src.api.security import api_key_auth, audit_logger
+from src.lsp import HedLspClient
 from src.telemetry import LocalFileStorage, TelemetryCollector, TelemetryEvent
 from src.utils.openrouter_llm import create_openrouter_llm, get_model_name
 from src.utils.schema_loader import HedSchemaLoader
@@ -48,6 +49,11 @@ workflow: HedAnnotationWorkflow | None = None
 vision_agent: VisionAgent | None = None
 schema_loader: HedSchemaLoader | None = None
 
+# Persistent LSP client; lifetime = process lifetime. Spawned in lifespan
+# so every request reuses one warm Node child instead of cold-booting
+# hed-suggest per keyword.
+lsp_client: HedLspClient | None = None
+
 # Telemetry collector (initialized in lifespan)
 telemetry_collector: TelemetryCollector | None = None
 
@@ -78,6 +84,25 @@ def _derive_user_id(token: str) -> str:
     return derived.hex()
 
 
+# Sentinel used by the workflow factories to mean "fall back to the
+# server-wide lsp_client global". Per-request callers can pass an
+# explicit None to opt out, or another HedLspClient instance to override.
+_USE_GLOBAL_LSP: HedLspClient = object()  # type: ignore[assignment]
+
+
+def _resolve_lsp_client(
+    explicit: HedLspClient | None,
+) -> HedLspClient | None:
+    """Pick the per-request LSP client.
+
+    Explicit values (including ``None``) win. The sentinel
+    ``_USE_GLOBAL_LSP`` means "use the lifespan-managed global".
+    """
+    if explicit is _USE_GLOBAL_LSP:
+        return lsp_client
+    return explicit
+
+
 def create_openrouter_workflow(
     api_key: str,
     annotation_model: str | None = None,
@@ -89,6 +114,7 @@ def create_openrouter_workflow(
     schema_dir: str | Path | None = None,
     validator_path: str | Path | None = None,
     use_js_validator: bool = True,
+    lsp_client: HedLspClient | None = _USE_GLOBAL_LSP,
 ) -> HedAnnotationWorkflow:
     """Create a workflow with OpenRouter LLMs.
 
@@ -133,7 +159,10 @@ def create_openrouter_workflow(
 
     actual_eval_provider = eval_provider or default_eval_provider or None
 
-    # Create LLMs
+    # Create LLMs.
+    # The annotation LLM keeps reasoning enabled — that's the model
+    # doing the actual HED tag synthesis where extended thinking
+    # measurably improves first-attempt quality.
     annotation_llm = create_openrouter_llm(
         model=actual_annotation_model,
         api_key=api_key,
@@ -141,12 +170,16 @@ def create_openrouter_workflow(
         provider=actual_annotation_provider,
         user_id=actual_user_id,
     )
+    # Evaluation / assessment / feedback / keyword extraction are short
+    # structured tasks; reasoning adds 5-10 s per call without
+    # measurable quality benefit. See #150.
     evaluation_llm = create_openrouter_llm(
         model=actual_eval_model,
         api_key=api_key,
         temperature=actual_temperature,
         provider=actual_eval_provider,
         user_id=actual_user_id,
+        disable_reasoning=True,
     )
     assessment_llm = create_openrouter_llm(
         model=actual_eval_model,
@@ -154,6 +187,7 @@ def create_openrouter_workflow(
         temperature=actual_temperature,
         provider=actual_eval_provider,
         user_id=actual_user_id,
+        disable_reasoning=True,
     )
     feedback_llm = create_openrouter_llm(
         model=actual_eval_model,
@@ -161,20 +195,37 @@ def create_openrouter_workflow(
         temperature=actual_temperature,
         provider=actual_eval_provider,
         user_id=actual_user_id,
+        disable_reasoning=True,
+    )
+    # Keyword extraction (#148): use the fast annotation model with
+    # reasoning explicitly disabled and a small token cap. The
+    # task is "list 5-10 keywords"; the heavier eval model used here
+    # previously cost ~10 s per call.
+    keyword_llm = create_openrouter_llm(
+        model=actual_annotation_model,
+        api_key=api_key,
+        temperature=actual_temperature,
+        provider=actual_annotation_provider,
+        user_id=actual_user_id,
+        max_tokens=200,
+        disable_reasoning=True,
     )
 
     # Create and return workflow
-    # Only use JS validator if validator_path is available
-    # Note: Semantic search now uses hed-lsp CLI instead of keyword extraction LLM
+    # Only use JS validator if validator_path is available.
+    # The LSP client (when provided) backs the persistent hed-lsp connection
+    # used for both semantic preprocessing and tag-replacement suggestions.
     actual_use_js = use_js_validator and validator_path is not None
     return HedAnnotationWorkflow(
         llm=annotation_llm,
         evaluation_llm=evaluation_llm,
         assessment_llm=assessment_llm,
         feedback_llm=feedback_llm,
+        keyword_llm=keyword_llm,
         schema_dir=Path(schema_dir) if schema_dir else None,
         validator_path=Path(validator_path) if validator_path else None,
         use_js_validator=actual_use_js,
+        lsp_client=_resolve_lsp_client(lsp_client),
     )
 
 
@@ -186,6 +237,7 @@ def create_byok_workflow(
     eval_provider: str | None = None,
     temperature: float | None = None,
     user_id_override: str | None = None,
+    lsp_client: HedLspClient | None = _USE_GLOBAL_LSP,
 ) -> HedAnnotationWorkflow:
     """Create a workflow for BYOK mode using the user's OpenRouter key.
 
@@ -217,6 +269,7 @@ def create_byok_workflow(
         schema_dir=_byok_config.get("schema_dir"),
         validator_path=_byok_config.get("validator_path"),
         use_js_validator=_byok_config.get("use_js_validator", True),
+        lsp_client=lsp_client,
     )
 
 
@@ -342,6 +395,44 @@ async def lifespan(app: FastAPI):
     print(f"Schema directory: {schema_dir or 'GitHub (dynamic fetch)'}")
     print(f"Validator path: {validator_path or 'None (using Python validator)'}")
 
+    # Spawn the persistent hed-lsp child once for the lifetime of the
+    # process. Per-request workflows reuse this single warm connection
+    # instead of cold-booting hed-suggest per keyword. Set HED_LSP_DISABLE=1
+    # to fall back to keyword-only preprocessing (no LSP enrichment).
+    # Failures here are logged via the structured logger (not print) so
+    # operators can detect a silently-degraded server from log
+    # aggregation.
+    global lsp_client
+    lsp_logger = logging.getLogger("hedit.lsp")
+    if os.getenv("HED_LSP_DISABLE", "").lower() in ("1", "true", "yes"):
+        lsp_logger.info("LSP client disabled via HED_LSP_DISABLE")
+        lsp_client = None
+    else:
+        server_js_env = os.getenv("HED_LSP_SERVER_JS")
+        default_server_js = Path("/app/hed-lsp/server/out/server.js")
+        server_js_path = Path(server_js_env) if server_js_env else default_server_js
+        if not server_js_path.exists():
+            lsp_logger.error(
+                "LSP server.js not found at %s; set HED_LSP_SERVER_JS or install "
+                "hed-lsp. Continuing without LSP enrichment.",
+                server_js_path,
+            )
+            lsp_client = None
+        else:
+            try:
+                lsp_client = await HedLspClient.spawn_stdio(
+                    server_js_path,
+                    schema_version=os.getenv("HED_SCHEMA_VERSION", "8.4.0"),
+                )
+                lsp_logger.info("LSP client connected (server.js=%s)", server_js_path)
+            except (RuntimeError, OSError, TimeoutError) as exc:
+                lsp_logger.error(
+                    "LSP client spawn failed; continuing without LSP enrichment. "
+                    "Set HED_LSP_DISABLE=1 to suppress this error.",
+                    exc_info=exc,
+                )
+                lsp_client = None
+
     # Initialize workflow based on provider
     if llm_provider == "openrouter":
         # OpenRouter configuration - use unified workflow creation
@@ -364,6 +455,7 @@ async def lifespan(app: FastAPI):
             schema_dir=schema_dir,
             validator_path=validator_path if use_js_validator else None,
             use_js_validator=use_js_validator,
+            lsp_client=lsp_client,
         )
     else:
         # Ollama configuration (default)
@@ -384,6 +476,7 @@ async def lifespan(app: FastAPI):
             schema_dir=Path(schema_dir) if schema_dir else None,
             validator_path=Path(validator_path) if use_js_validator and validator_path else None,
             use_js_validator=use_js_validator,
+            lsp_client=lsp_client,
         )
 
     # Set global schema_loader from workflow
@@ -428,6 +521,12 @@ async def lifespan(app: FastAPI):
 
     # Shutdown
     print("Shutting down HEDit...")
+    if lsp_client is not None:
+        try:
+            await lsp_client.shutdown()
+            lsp_logger.info("LSP client shut down cleanly")
+        except Exception as exc:
+            lsp_logger.error("LSP client shutdown error", exc_info=exc)
 
 
 # Create FastAPI app