Struct LspLanguageHealth 

pub struct LspLanguageHealth {

    pub language: String,
    pub status: String,
    pub uptime: Option<String>,
    pub diagnostics_strategy: Option<String>,
    pub supports_call_hierarchy: Option<bool>,
    pub supports_diagnostics: Option<bool>,
    pub supports_definition: Option<bool>,
    pub indexing_status: Option<String>,
    pub indexing_source: Option<String>,
    pub indexing_duration_secs: Option<u64>,
    pub navigation_ready: Option<bool>,
    pub navigation_verified: Option<bool>,
    pub probe_verified: bool,
    pub navigation_tested: Option<bool>,
    pub call_hierarchy_verified: bool,
    pub install_hint: Option<String>,
    pub server_name: Option<String>,
    pub registrations_received: Option<u32>,
    pub indexing_progress_percent: Option<u8>,
    pub degraded_tools: Vec<DegradedToolInfo>,
    pub last_probe_age_secs: Option<u32>,
}

Per-language LSP health status.

Fields

language: String

Language ID (e.g., “rust”, “typescript”).

status: String

Status of the language server process.

Lifecycle: unavailable → starting → warming_up → ready A ready LSP may be downgraded to degraded if a live probe fails.

• "unavailable": No LSP process running or detected
• "starting": Process exists, no capability info yet (lazy start)
• "warming_up": Process running, navigation_ready not yet confirmed
• "ready": Initialize handshake complete, navigation_ready=true, and live probe succeeded (navigation_verified=Some(true))
• "degraded": Initialize handshake completed (navigation_ready=true) but live probe failed (navigation_verified=Some(false)). Navigation MAY still work — retry or use with caution.

uptime: Option<String>

Time since LSP process started, formatted as a human-readable string (e.g., “45s”).

diagnostics_strategy: Option<String>

How diagnostics work for this language.

supports_call_hierarchy: Option<bool>

Whether call hierarchy is supported (affects trace, inspect with dependencies).

supports_diagnostics: Option<bool>

Whether diagnostics are supported (affects LSP health quality).

supports_definition: Option<bool>

Whether definition is supported (affects locate).

indexing_status: Option<String>

Background indexing status: "complete", "in_progress", or None.

Independent of overall status — an LSP can be “ready” for navigation while still indexing in the background.

indexing_source: Option<String>

indexing_duration_secs: Option<u64>

navigation_ready: Option<bool>

Whether the LSP advertised navigation capabilities during initialize.

This reflects capability negotiation only — it does NOT guarantee navigation actually works. For live verification, check navigation_verified.

true once the LSP initialize handshake completes with definitionProvider: true. Independent of indexing_status — navigation works during indexing but results may be partial until indexing completes.

navigation_verified: Option<bool>

Whether navigation was verified by a live probe (not just capability advertisement). Distinct from navigation_ready which reflects capability negotiation only.

• Some(true): live probe succeeded — navigation is operational
• Some(false): live probe failed — navigation may be broken despite navigation_ready: true
• None: probe not yet run (freshness unknown)

probe_verified: bool

Whether the status was verified by a live probe (rather than just progress notifications). When true, the agent can trust the status.

navigation_tested: Option<bool>

Whether navigation (locate, trace) was confirmed by a live probe.

true only when a live goto_definition probe request succeeded — meaning the LSP returned a real location, not just that it advertised the capability in the initialize handshake. Stronger signal than navigation_ready alone.

Note: This is an independent signal from status: "ready". An LSP can be in the "ready" status (handshake completed) even if a live probe has not yet been executed or has failed (in which case navigation_tested will be None or Some(false) respectively).

Agents should prefer this over probe_verified — it has the same meaning but communicates intent more clearly.

call_hierarchy_verified: bool

Whether the call hierarchy capability was verified by a live probe.

install_hint: Option<String>

Install guidance when LSP is unavailable.

Provides actionable commands users can run to install their LSP servers. None when LSP is running or language not detected at all.

server_name: Option<String>

The LSP server identity (e.g., “rust-analyzer”, “Pyright”, “gopls”). Useful for distinguishing which Python LSP is running. None when the process is not running or server omitted serverInfo.

registrations_received: Option<u32>

Number of dynamic capability registrations received from the LSP server. Useful for diagnosing dynamic registration delays (e.g., jdtls).

indexing_progress_percent: Option<u8>

Indexing progress percentage (0-100) if the LSP reports it via workDoneProgress. None when the LSP does not report progress or indexing is complete.

degraded_tools: Vec<DegradedToolInfo>

Tools that are degraded (using fallback) for this language.

Empty when LSP is fully operational. Lists which tools lose LSP support with detailed severity and description for each.

last_probe_age_secs: Option<u32>

Seconds since last liveness probe for this language.

Trait Implementations

impl Debug for LspLanguageHealth

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for LspLanguageHealth

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for LspLanguageHealth

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl Serialize for LspLanguageHealth

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.