@thotischner/observability-mcp 1.0.0

package/dist/index.js

@@ -0,0 +1,421 @@
+#!/usr/bin/env node
+import express from "express";
+import { randomUUID } from "node:crypto";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { z } from "zod";
+import { loadConfig, saveConfig, DEFAULT_HEALTH_THRESHOLDS, DEFAULT_SETTINGS } from "./config/loader.js";
+import { ConnectorRegistry, getSupportedTypes } from "./connectors/registry.js";
+import { listSourcesHandler } from "./tools/list-sources.js";
+import { listServicesHandler } from "./tools/list-services.js";
+import { queryMetricsHandler } from "./tools/query-metrics.js";
+import { queryLogsHandler } from "./tools/query-logs.js";
+import { getServiceHealthHandler, setHealthThresholds } from "./tools/get-service-health.js";
+import { detectAnomaliesHandler } from "./tools/detect-anomalies.js";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+function applyConfigToRuntime(config, registry) {
+    setHealthThresholds(config.healthThresholds);
+}
+/** Build a dynamic description of available metrics from all connected sources */
+function getAvailableMetricNames(registry) {
+    const allMetrics = new Map(); // name → description
+    for (const connector of registry.getBySignal("metrics")) {
+        for (const m of connector.getMetrics()) {
+            if (!allMetrics.has(m.name)) {
+                allMetrics.set(m.name, m.description || m.name);
+            }
+        }
+    }
+    if (allMetrics.size === 0)
+        return "No metrics sources configured.";
+    return Array.from(allMetrics.entries())
+        .map(([name, desc]) => `${name} (${desc})`)
+        .join(", ");
+}
+/** Validate source URL: must be http/https, reject obviously dangerous targets */
+function validateSourceUrl(url) {
+    try {
+        const parsed = new URL(url);
+        if (!["http:", "https:"].includes(parsed.protocol)) {
+            return `Invalid URL scheme "${parsed.protocol}". Only http and https are allowed.`;
+        }
+        // Block cloud metadata endpoints
+        const host = parsed.hostname.toLowerCase();
+        if (host === "169.254.169.254" || host === "metadata.google.internal") {
+            return "Access to cloud metadata endpoints is not allowed.";
+        }
+        return null;
+    }
+    catch {
+        return `Invalid URL: "${url}"`;
+    }
+}
+async function main() {
+    let config = loadConfig();
+    const registry = new ConnectorRegistry();
+    await registry.initialize(config);
+    applyConfigToRuntime(config, registry);
+    const mcpServer = new McpServer({
+        name: "observability-mcp",
+        version: "1.0.0",
+    });
+    // --- Register tools with Zod schemas ---
+    mcpServer.tool("list_sources", "List all configured observability backends and their connection status. Use this to discover what data sources are available.", {}, async () => listSourcesHandler(registry));
+    mcpServer.tool("list_services", "List all monitored services discovered across all connected backends. Returns service names, their data sources, and signal types (metrics/logs).", { filter: z.string().optional().describe("Optional filter to match service names") }, async (args) => listServicesHandler(registry, args));
+    const metricsList = getAvailableMetricNames(registry);
+    const metricNames = registry.getBySignal("metrics").flatMap(c => c.getMetrics().map(m => m.name));
+    const uniqueNames = [...new Set(metricNames)];
+    mcpServer.tool("query_metrics", `Query a specific metric for a service over a given timeframe. Returns time-series data with pre-computed summary statistics (current, average, min, max, trend). Available metrics: ${metricsList}`, {
+        service: z.string().describe("Service name (e.g. 'api-gateway', 'payment-service')"),
+        metric: z.string().describe(`Metric name. Available: ${uniqueNames.join(", ")}`),
+        duration: z.string().optional().describe("Time range (e.g. '5m', '1h', '24h'). Default: '5m'"),
+        source: z.string().optional().describe("Specific source name. If omitted, queries all metrics backends."),
+    }, async (args) => queryMetricsHandler(registry, args));
+    mcpServer.tool("query_logs", "Query logs for a service over a given timeframe. Returns log entries with a summary including error/warning counts and top error patterns.", {
+        service: z.string().describe("Service name (e.g. 'payment-service')"),
+        query: z.string().optional().describe("Optional search query to filter log messages (regex supported)"),
+        duration: z.string().optional().describe("Time range (e.g. '5m', '1h', '24h'). Default: '5m'"),
+        level: z.string().optional().describe("Filter by log level: 'error', 'warn', 'info', 'debug'"),
+        limit: z.number().optional().describe("Maximum log entries to return. Default: 100"),
+    }, async (args) => queryLogsHandler(registry, args));
+    mcpServer.tool("get_service_health", "Get an aggregated health overview for a service combining metrics AND logs. Returns health score (0-100), status (healthy/degraded/critical), key metrics, log error summary, anomalies, and cross-signal correlations.", {
+        service: z.string().describe("Service name to check health for"),
+    }, async (args) => getServiceHealthHandler(registry, args));
+    mcpServer.tool("detect_anomalies", "Scan for anomalies across all monitored services (or a specific one). Uses z-score analysis on metrics, checks log error spikes, and correlates signals. Returns anomalies with severity ratings.", {
+        service: z.string().optional().describe("Specific service to scan. If omitted, scans all."),
+        duration: z.string().optional().describe("Time range to analyze (e.g. '5m', '15m', '1h'). Default: '10m'"),
+        sensitivity: z.enum(["low", "medium", "high"]).optional().describe("Detection sensitivity: low (>3σ), medium (>2σ), high (>1.5σ). Default: 'medium'"),
+    }, async (args) => detectAnomaliesHandler(registry, args));
+    // --- HTTP server ---
+    const app = express();
+    app.use(express.json({ limit: "1mb" }));
+    // Security headers
+    app.use((_req, res, next) => {
+        res.setHeader("X-Content-Type-Options", "nosniff");
+        res.setHeader("X-Frame-Options", "DENY");
+        res.setHeader("X-XSS-Protection", "1; mode=block");
+        res.setHeader("Referrer-Policy", "strict-origin-when-cross-origin");
+        next();
+    });
+    // Serve Web UI
+    app.use(express.static(join(__dirname, "ui")));
+    // --- API endpoints for Web UI ---
+    // List sources with health status
+    app.get("/api/sources", async (_req, res) => {
+        const health = await registry.healthCheckAll();
+        const configs = registry.getSourceConfigs();
+        const sources = configs.map((c) => {
+            const connector = registry.getByName(c.name);
+            return {
+                name: c.name,
+                type: c.type,
+                url: c.url,
+                enabled: c.enabled,
+                auth: c.auth ? { type: c.auth.type } : undefined,
+                tls: c.tls || undefined,
+                signalType: connector?.signalType || null,
+                status: health[c.name]?.status || (c.enabled ? "down" : "disabled"),
+                latencyMs: health[c.name]?.latencyMs || null,
+                message: health[c.name]?.message || null,
+            };
+        });
+        res.json(sources);
+    });
+    // Get supported connector types
+    app.get("/api/source-types", (_req, res) => {
+        res.json(getSupportedTypes());
+    });
+    // Add a new source
+    app.post("/api/sources", async (req, res) => {
+        const { name, type, url, enabled, auth, tls } = req.body;
+        if (!name || !type || !url) {
+            res.status(400).json({ error: "name, type, and url are required" });
+            return;
+        }
+        const urlErr = validateSourceUrl(url);
+        if (urlErr) {
+            res.status(400).json({ error: urlErr });
+            return;
+        }
+        const existing = registry.getSourceConfigs().find((s) => s.name === name);
+        if (existing) {
+            res.status(409).json({ error: `Source "${name}" already exists` });
+            return;
+        }
+        const source = { name, type, url, enabled: enabled !== false, auth, tls };
+        await registry.addSource(source);
+        saveConfig(config = { ...config, sources: registry.getSourceConfigs() });
+        res.status(201).json({ ok: true, source });
+    });
+    // Update an existing source
+    app.put("/api/sources/:name", async (req, res) => {
+        const oldName = req.params.name;
+        const { name, type, url, enabled, auth, tls } = req.body;
+        const existing = registry.getSourceConfigs().find((s) => s.name === oldName);
+        if (!existing) {
+            res.status(404).json({ error: `Source "${oldName}" not found` });
+            return;
+        }
+        const newUrl = url || existing.url;
+        if (url) {
+            const urlErr = validateSourceUrl(newUrl);
+            if (urlErr) {
+                res.status(400).json({ error: urlErr });
+                return;
+            }
+        }
+        const source = {
+            name: name || oldName,
+            type: type || existing.type,
+            url: newUrl,
+            enabled: enabled !== undefined ? enabled : existing.enabled,
+            auth: auth !== undefined ? auth : existing.auth,
+            tls: tls !== undefined ? tls : existing.tls,
+        };
+        await registry.updateSource(oldName, source);
+        saveConfig(config = { ...config, sources: registry.getSourceConfigs() });
+        res.json({ ok: true, source });
+    });
+    // Delete a source
+    app.delete("/api/sources/:name", async (req, res) => {
+        const name = req.params.name;
+        const existing = registry.getSourceConfigs().find((s) => s.name === name);
+        if (!existing) {
+            res.status(404).json({ error: `Source "${name}" not found` });
+            return;
+        }
+        await registry.removeSource(name);
+        saveConfig(config = { ...config, sources: registry.getSourceConfigs() });
+        res.json({ ok: true });
+    });
+    // Test a source connection (without saving)
+    app.post("/api/sources/test", async (req, res) => {
+        const { name, type, url, enabled, auth, tls } = req.body;
+        if (!type || !url) {
+            res.status(400).json({ error: "type and url are required" });
+            return;
+        }
+        const urlErr = validateSourceUrl(url);
+        if (urlErr) {
+            res.status(400).json({ error: urlErr });
+            return;
+        }
+        const result = await registry.testConnection({
+            name: name || "test",
+            type,
+            url,
+            enabled: enabled !== false,
+            auth,
+            tls,
+        });
+        res.json(result);
+    });
+    // Toggle source enabled/disabled
+    app.patch("/api/sources/:name/toggle", async (req, res) => {
+        const name = req.params.name;
+        const existing = registry.getSourceConfigs().find((s) => s.name === name);
+        if (!existing) {
+            res.status(404).json({ error: `Source "${name}" not found` });
+            return;
+        }
+        const updated = { ...existing, enabled: !existing.enabled };
+        await registry.updateSource(name, updated);
+        saveConfig(config = { ...config, sources: registry.getSourceConfigs() });
+        res.json({ ok: true, enabled: updated.enabled });
+    });
+    /** Safely parse JSON from MCP tool result */
+    function parseToolResult(result) {
+        try {
+            return JSON.parse(result.content[0]?.text || "{}");
+        }
+        catch {
+            return { error: "Failed to parse tool result" };
+        }
+    }
+    // List discovered services
+    app.get("/api/services", async (_req, res) => {
+        try {
+            const result = await listServicesHandler(registry, {});
+            res.json(parseToolResult(result));
+        }
+        catch {
+            res.status(500).json({ error: "Failed to list services" });
+        }
+    });
+    // Health endpoint for UI dashboard
+    app.get("/api/health/:service", async (req, res) => {
+        try {
+            const result = await getServiceHealthHandler(registry, { service: req.params.service });
+            res.json(parseToolResult(result));
+        }
+        catch {
+            res.status(500).json({ error: "Failed to get service health" });
+        }
+    });
+    // Health for all services
+    app.get("/api/health", async (_req, res) => {
+        try {
+            const servicesResult = await listServicesHandler(registry, {});
+            const parsed = parseToolResult(servicesResult);
+            const services = parsed?.services || [];
+            const health = {};
+            for (const svc of services) {
+                try {
+                    const result = await getServiceHealthHandler(registry, { service: svc.name });
+                    health[svc.name] = parseToolResult(result);
+                }
+                catch {
+                    health[svc.name] = { error: "failed to fetch health" };
+                }
+            }
+            res.json(health);
+        }
+        catch {
+            res.status(500).json({ error: "Failed to get health data" });
+        }
+    });
+    // --- Settings API ---
+    // Get general settings
+    app.get("/api/settings", (_req, res) => {
+        res.json(config.settings);
+    });
+    // Update general settings
+    app.put("/api/settings", (req, res) => {
+        config = { ...config, settings: { ...config.settings, ...req.body } };
+        saveConfig(config);
+        res.json({ ok: true, settings: config.settings });
+    });
+    // Get defaults (for reset buttons in UI)
+    app.get("/api/settings/defaults", (_req, res) => {
+        res.json({
+            settings: DEFAULT_SETTINGS,
+            healthThresholds: DEFAULT_HEALTH_THRESHOLDS,
+        });
+    });
+    // --- Health Thresholds API ---
+    app.get("/api/health-thresholds", (_req, res) => {
+        res.json(config.healthThresholds);
+    });
+    app.put("/api/health-thresholds", (req, res) => {
+        config = { ...config, healthThresholds: { ...config.healthThresholds, ...req.body } };
+        applyConfigToRuntime(config, registry);
+        saveConfig(config);
+        res.json({ ok: true, healthThresholds: config.healthThresholds });
+    });
+    // --- Per-Source Metrics API ---
+    // Get metrics for a source (active metrics or defaults)
+    app.get("/api/sources/:name/metrics", (req, res) => {
+        const connector = registry.getByName(req.params.name);
+        if (!connector) {
+            res.status(404).json({ error: `Source "${req.params.name}" not found` });
+            return;
+        }
+        res.json({
+            metrics: connector.getMetrics(),
+            defaults: connector.getDefaultMetrics(),
+        });
+    });
+    // Update metrics for a source
+    app.put("/api/sources/:name/metrics", async (req, res) => {
+        const name = req.params.name;
+        const sourceIdx = config.sources.findIndex((s) => s.name === name);
+        if (sourceIdx === -1) {
+            res.status(404).json({ error: `Source "${name}" not found` });
+            return;
+        }
+        config.sources[sourceIdx].metrics = req.body.metrics || [];
+        // Reconnect to pick up new metrics
+        await registry.updateSource(name, config.sources[sourceIdx]);
+        saveConfig(config);
+        res.json({ ok: true });
+    });
+    // Reset a source's metrics to connector defaults
+    app.delete("/api/sources/:name/metrics", async (req, res) => {
+        const name = req.params.name;
+        const sourceIdx = config.sources.findIndex((s) => s.name === name);
+        if (sourceIdx === -1) {
+            res.status(404).json({ error: `Source "${name}" not found` });
+            return;
+        }
+        delete config.sources[sourceIdx].metrics;
+        await registry.updateSource(name, config.sources[sourceIdx]);
+        saveConfig(config);
+        res.json({ ok: true });
+    });
+    // MCP Streamable HTTP transport — stateful sessions
+    const transports = new Map();
+    const sessionLastActive = new Map();
+    const SESSION_TTL_MS = 30 * 60 * 1000; // 30 min idle timeout
+    // Clean up idle sessions every 5 minutes
+    setInterval(() => {
+        const now = Date.now();
+        for (const [sid, lastActive] of sessionLastActive) {
+            if (now - lastActive > SESSION_TTL_MS) {
+                transports.delete(sid);
+                sessionLastActive.delete(sid);
+                console.log(`Session ${sid} expired (idle)`);
+            }
+        }
+    }, 5 * 60 * 1000);
+    app.post("/mcp", async (req, res) => {
+        const sessionId = req.headers["mcp-session-id"];
+        let transport;
+        if (sessionId && transports.has(sessionId)) {
+            transport = transports.get(sessionId);
+        }
+        else {
+            transport = new StreamableHTTPServerTransport({
+                sessionIdGenerator: () => randomUUID(),
+            });
+            transport.onclose = () => {
+                // Clean up session on close
+                for (const [sid, t] of transports) {
+                    if (t === transport) {
+                        transports.delete(sid);
+                        break;
+                    }
+                }
+            };
+            await mcpServer.connect(transport);
+        }
+        await transport.handleRequest(req, res, req.body);
+        // Store session after handling (sessionId is set during handleRequest)
+        const sid = res.getHeader("mcp-session-id");
+        if (sid) {
+            if (!transports.has(sid))
+                transports.set(sid, transport);
+            sessionLastActive.set(sid, Date.now());
+        }
+    });
+    app.get("/mcp", async (req, res) => {
+        const sessionId = req.headers["mcp-session-id"];
+        const transport = transports.get(sessionId);
+        if (!transport) {
+            res.status(400).json({ error: "No active session" });
+            return;
+        }
+        await transport.handleRequest(req, res);
+    });
+    app.delete("/mcp", async (req, res) => {
+        const sessionId = req.headers["mcp-session-id"];
+        const transport = transports.get(sessionId);
+        if (transport) {
+            await transport.handleRequest(req, res);
+            transports.delete(sessionId);
+            sessionLastActive.delete(sessionId);
+        }
+        else {
+            res.status(400).json({ error: "No active session" });
+        }
+    });
+    const PORT = parseInt(process.env.PORT || "3000");
+    app.listen(PORT, () => {
+        console.log(`observability-mcp server running on port ${PORT}`);
+        console.log(`  MCP endpoint: http://localhost:${PORT}/mcp`);
+        console.log(`  Web UI: http://localhost:${PORT}`);
+        console.log(`  Connectors: ${registry.getAll().map((c) => c.name).join(", ")}`);
+    });
+}
+main().catch(console.error);

package/dist/tools/detect-anomalies.d.ts

@@ -0,0 +1,33 @@
+import type { ConnectorRegistry } from "../connectors/registry.js";
+export declare const detectAnomaliesDefinition: {
+    name: "detect_anomalies";
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            service: {
+                type: string;
+                description: string;
+            };
+            duration: {
+                type: string;
+                description: string;
+            };
+            sensitivity: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+        };
+    };
+};
+export declare function detectAnomaliesHandler(registry: ConnectorRegistry, args: {
+    service?: string;
+    duration?: string;
+    sensitivity?: string;
+}): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;

package/dist/tools/detect-anomalies.js

@@ -0,0 +1,137 @@
+import { detectRecentAnomaly } from "../analysis/anomaly.js";
+export const detectAnomaliesDefinition = {
+    name: "detect_anomalies",
+    description: "Scan for anomalies across all monitored services (or a specific service). Detects metric deviations using z-score analysis against recent baseline, checks log error spikes, and correlates signals across metrics and logs. Returns anomalies with severity ratings and cross-signal correlations.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            service: {
+                type: "string",
+                description: "Specific service to scan. If omitted, scans all services.",
+            },
+            duration: {
+                type: "string",
+                description: "Time range to analyze (e.g. '5m', '15m', '1h'). Default: '10m'",
+            },
+            sensitivity: {
+                type: "string",
+                enum: ["low", "medium", "high"],
+                description: "Detection sensitivity. 'low' = major deviations only (>3σ), 'medium' = moderate (>2σ), 'high' = subtle changes (>1.5σ). Default: 'medium'",
+            },
+        },
+    },
+};
+const SENSITIVITY_THRESHOLDS = {
+    low: 3.0,
+    medium: 2.0,
+    high: 1.5,
+};
+const KEY_METRICS = ["cpu", "error_rate", "latency_p99", "request_rate"];
+export async function detectAnomaliesHandler(registry, args) {
+    const duration = args.duration || "10m";
+    const threshold = SENSITIVITY_THRESHOLDS[args.sensitivity || "medium"] || 2.0;
+    // Discover services to scan
+    const metricsConnectors = registry.getBySignal("metrics");
+    const logConnectors = registry.getBySignal("logs");
+    let serviceNames = [];
+    if (args.service) {
+        serviceNames = [args.service];
+    }
+    else {
+        for (const connector of metricsConnectors) {
+            const services = await connector.listServices();
+            for (const s of services) {
+                if (!serviceNames.includes(s.name))
+                    serviceNames.push(s.name);
+            }
+        }
+    }
+    const allAnomalies = [];
+    const allCorrelations = [];
+    for (const serviceName of serviceNames) {
+        // Check metrics
+        for (const connector of metricsConnectors) {
+            if (!connector.queryMetrics)
+                continue;
+            for (const metric of KEY_METRICS) {
+                try {
+                    const result = await connector.queryMetrics({ service: serviceName, metric, duration });
+                    const values = result.values.map((v) => v.value);
+                    const anomaly = detectRecentAnomaly(values, 5, threshold);
+                    if (anomaly.isAnomaly) {
+                        const deviationPercent = anomaly.baselineAvg === 0
+                            ? 100
+                            : Math.round(((anomaly.recentAvg - anomaly.baselineAvg) / anomaly.baselineAvg) * 100);
+                        allAnomalies.push({
+                            metric,
+                            severity: Math.abs(anomaly.zScore) >= 3 ? "high" : Math.abs(anomaly.zScore) >= 2 ? "medium" : "low",
+                            description: `${metric} is ${anomaly.zScore.toFixed(1)}σ ${anomaly.zScore > 0 ? "above" : "below"} baseline (${anomaly.baselineAvg.toFixed(2)} → ${anomaly.recentAvg.toFixed(2)})`,
+                            currentValue: anomaly.recentAvg,
+                            baselineValue: anomaly.baselineAvg,
+                            deviationPercent,
+                            source: connector.name,
+                            service: serviceName,
+                        });
+                    }
+                }
+                catch {
+                    // Skip metrics that don't exist for this service
+                }
+            }
+        }
+        // Check logs for error spikes
+        for (const connector of logConnectors) {
+            if (!connector.queryLogs)
+                continue;
+            try {
+                const logs = await connector.queryLogs({ service: serviceName, duration, limit: 500 });
+                if (logs.summary.errorCount > 5) {
+                    const errorRatio = logs.summary.total > 0
+                        ? logs.summary.errorCount / logs.summary.total
+                        : 0;
+                    if (errorRatio > 0.1) {
+                        allAnomalies.push({
+                            metric: "log_error_rate",
+                            severity: errorRatio > 0.3 ? "high" : errorRatio > 0.15 ? "medium" : "low",
+                            description: `${Math.round(errorRatio * 100)}% of logs are errors (${logs.summary.errorCount}/${logs.summary.total}). Top: ${logs.summary.topPatterns[0] || "N/A"}`,
+                            currentValue: logs.summary.errorCount,
+                            baselineValue: 0,
+                            deviationPercent: 100,
+                            source: connector.name,
+                            service: serviceName,
+                        });
+                    }
+                }
+            }
+            catch {
+                // Skip if logs unavailable
+            }
+        }
+    }
+    // Cross-signal correlation
+    if (allAnomalies.length > 0) {
+        const servicesWithAnomalies = [...new Set(allAnomalies.map((a) => a.service))];
+        for (const svc of servicesWithAnomalies) {
+            const svcAnomalies = allAnomalies.filter((a) => a.service === svc);
+            const metricTypes = svcAnomalies.map((a) => a.metric).filter((m) => m !== "log_error_rate");
+            const hasLogAnomaly = svcAnomalies.some((a) => a.metric === "log_error_rate");
+            if (metricTypes.length > 0 && hasLogAnomaly) {
+                allCorrelations.push(`${svc}: metric anomalies (${metricTypes.join(", ")}) correlate with elevated log error rate`);
+            }
+            if (metricTypes.includes("cpu") && metricTypes.includes("latency_p99")) {
+                allCorrelations.push(`${svc}: CPU spike and latency increase detected simultaneously — possible resource saturation`);
+            }
+        }
+    }
+    const result = {
+        scannedServices: serviceNames.length,
+        anomalies: allAnomalies,
+        correlations: allCorrelations,
+        summary: allAnomalies.length === 0
+            ? "All services healthy — no anomalies detected."
+            : `${allAnomalies.length} anomal${allAnomalies.length === 1 ? "y" : "ies"} detected across ${[...new Set(allAnomalies.map((a) => a.service))].length} service(s).`,
+    };
+    return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+    };
+}

package/dist/tools/get-service-health.d.ts

@@ -0,0 +1,25 @@
+import type { ConnectorRegistry } from "../connectors/registry.js";
+import type { HealthThresholds } from "../types.js";
+export declare function setHealthThresholds(t: HealthThresholds): void;
+export declare const getServiceHealthDefinition: {
+    name: "get_service_health";
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            service: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function getServiceHealthHandler(registry: ConnectorRegistry, args: {
+    service: string;
+}): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;