@havesomecode/kibana-mcp-server 1.2.0 → 1.3.0

package/dist/src/kibana_client.js

@@ -9,6 +9,24 @@ class KibanaHttpError extends Error {
         this.name = "KibanaHttpError";
     }
 }
+export class KibanaRequestError extends Error {
+    code;
+    phase;
+    sourceId;
+    timeoutMs;
+    status;
+    causeCode;
+    constructor(code, phase, sourceId, timeoutMs, message, cause, status, causeCode) {
+        super(message, { cause });
+        this.code = code;
+        this.phase = phase;
+        this.sourceId = sourceId;
+        this.timeoutMs = timeoutMs;
+        this.status = status;
+        this.causeCode = causeCode;
+        this.name = "KibanaRequestError";
+    }
+}
 function joinUrl(baseUrl, path) {
     return path.startsWith("http://") || path.startsWith("https://")
         ? path
@@ -17,6 +35,39 @@ function joinUrl(baseUrl, path) {
 function encodeBasicAuth(username, password) {
     return Buffer.from(`${username}:${password}`).toString("base64");
 }
+function getNetworkCauseCode(error) {
+    if (!(error instanceof Error) || !error.cause || typeof error.cause !== "object") {
+        return undefined;
+    }
+    const code = error.cause.code;
+    return typeof code === "string" ? code : undefined;
+}
+function classifyNetworkError(causeCode) {
+    if (causeCode === "ENOTFOUND" || causeCode === "EAI_AGAIN") {
+        return "KIBANA_DNS";
+    }
+    if (causeCode?.startsWith("CERT_") ||
+        causeCode?.startsWith("ERR_TLS_") ||
+        [
+            "DEPTH_ZERO_SELF_SIGNED_CERT",
+            "SELF_SIGNED_CERT_IN_CHAIN",
+            "UNABLE_TO_VERIFY_LEAF_SIGNATURE",
+        ].includes(causeCode ?? "")) {
+        return "KIBANA_TLS";
+    }
+    if ([
+        "ECONNREFUSED",
+        "ECONNRESET",
+        "EHOSTUNREACH",
+        "ENETUNREACH",
+        "ETIMEDOUT",
+        "UND_ERR_CONNECT_TIMEOUT",
+        "UND_ERR_SOCKET",
+    ].includes(causeCode ?? "")) {
+        return "KIBANA_CONNECTION";
+    }
+    return "KIBANA_NETWORK";
+}
 function unwrapSearchResponse(raw) {
     if (!raw || typeof raw !== "object") {
         throw new Error("Unexpected Kibana search response shape");
@@ -46,7 +97,17 @@ function asArray(value) {
     return Array.isArray(value) ? value : [];
 }
 function normalizeFieldCapsResponse(raw) {
-    const fields = asRecord(asRecord(raw).fields);
+    const record = asRecord(raw);
+    if (!raw ||
+        typeof raw !== "object" ||
+        Array.isArray(raw) ||
+        !("fields" in record) ||
+        !record.fields ||
+        typeof record.fields !== "object" ||
+        Array.isArray(record.fields)) {
+        throw new Error("Unexpected Elasticsearch field capabilities response shape");
+    }
+    const fields = asRecord(record.fields);
     return Object.entries(fields)
         .map(([name, typeEntries]) => {
         const typeRecord = asRecord(typeEntries);
@@ -63,13 +124,21 @@ function normalizeFieldCapsResponse(raw) {
         .sort((left, right) => left.name.localeCompare(right.name));
 }
 function normalizeKibanaFieldsResponse(raw) {
-    const rawFields = Array.isArray(raw) ? raw : asArray(asRecord(raw).fields);
+    const record = asRecord(raw);
+    const rawFields = Array.isArray(raw)
+        ? raw
+        : raw && typeof raw === "object" && !Array.isArray(raw) && Array.isArray(record.fields)
+            ? record.fields
+            : undefined;
+    if (!rawFields) {
+        throw new Error("Unexpected Kibana fields response shape");
+    }
     return rawFields
         .map((field) => {
         const fieldRecord = asRecord(field);
         const name = fieldRecord.name;
         if (typeof name !== "string") {
-            return null;
+            throw new Error("Kibana fields response contained an entry without a field name");
         }
         const subType = asRecord(fieldRecord.subType);
         const nested = asRecord(subType.nested);
@@ -84,7 +153,6 @@ function normalizeKibanaFieldsResponse(raw) {
             subfields: [],
         };
     })
-        .filter((field) => field !== null)
         .sort((left, right) => left.name.localeCompare(right.name));
 }
 function resolveSchemaIndexPatterns(source, schemaBackend) {
@@ -259,18 +327,99 @@ function normalizeSearchSampleFields(raw) {
     }
     return [...fieldMap.values()].sort((left, right) => left.name.localeCompare(right.name));
 }
+class RequestGate {
+    maxConcurrency;
+    maxQueueDepth;
+    active = 0;
+    waiters = [];
+    constructor(maxConcurrency, maxQueueDepth) {
+        this.maxConcurrency = maxConcurrency;
+        this.maxQueueDepth = maxQueueDepth;
+    }
+    acquire(signal) {
+        if (signal.aborted) {
+            return Promise.reject(signal.reason);
+        }
+        if (this.active >= this.maxConcurrency && this.waiters.length >= this.maxQueueDepth) {
+            return Promise.reject(new RequestQueueFullError(this.maxQueueDepth));
+        }
+        return new Promise((resolve, reject) => {
+            const waiter = {
+                signal,
+                resolve,
+                reject,
+                onAbort: () => {
+                    const index = this.waiters.indexOf(waiter);
+                    if (index >= 0) {
+                        this.waiters.splice(index, 1);
+                    }
+                    reject(signal.reason);
+                },
+            };
+            signal.addEventListener("abort", waiter.onAbort, { once: true });
+            this.waiters.push(waiter);
+            this.dispatch();
+        });
+    }
+    dispatch() {
+        while (this.active < this.maxConcurrency) {
+            const waiter = this.waiters.shift();
+            if (!waiter) {
+                return;
+            }
+            waiter.signal.removeEventListener("abort", waiter.onAbort);
+            if (waiter.signal.aborted) {
+                waiter.reject(waiter.signal.reason);
+                continue;
+            }
+            this.active += 1;
+            let released = false;
+            waiter.resolve(() => {
+                if (released) {
+                    return;
+                }
+                released = true;
+                this.active -= 1;
+                this.dispatch();
+            });
+        }
+    }
+}
+class RequestQueueFullError extends Error {
+    maxQueueDepth;
+    constructor(maxQueueDepth) {
+        super(`Kibana request queue is full (${maxQueueDepth} waiting requests)`);
+        this.maxQueueDepth = maxQueueDepth;
+        this.name = "RequestQueueFullError";
+    }
+}
 export class KibanaClient {
     config;
-    constructor(config) {
+    requestGate;
+    queueTimeoutMs;
+    constructor(config, options = {}) {
         this.config = config;
+        this.requestGate = new RequestGate(options.maxConcurrency ?? 8, options.maxQueueDepth ?? 32);
+        this.queueTimeoutMs = Math.min(options.queueTimeoutMs ?? config.timeoutMs, config.timeoutMs);
     }
     async requestJson(url, options = {}) {
-        const controller = new AbortController();
-        const timeout = setTimeout(() => controller.abort(), this.config.timeoutMs);
+        const timeoutController = new AbortController();
+        const timeout = setTimeout(() => timeoutController.abort(new DOMException(`Timed out after ${this.config.timeoutMs}ms`, "TimeoutError")), this.config.timeoutMs);
+        const signal = options.callerSignal
+            ? AbortSignal.any([timeoutController.signal, options.callerSignal])
+            : timeoutController.signal;
+        const queueController = new AbortController();
+        const queueTimeout = setTimeout(() => queueController.abort(new DOMException(`Queue wait timed out after ${this.queueTimeoutMs}ms`, "TimeoutError")), this.queueTimeoutMs);
+        const queueSignal = AbortSignal.any([signal, queueController.signal]);
+        let phase = "queue";
+        let release;
         try {
+            release = await this.requestGate.acquire(queueSignal);
+            clearTimeout(queueTimeout);
+            phase = "request";
             const response = await fetch(url, {
                 method: options.method ?? "GET",
-                signal: controller.signal,
+                signal,
                 headers: {
                     Authorization: `Basic ${encodeBasicAuth(this.config.username, this.config.password)}`,
                     "Content-Type": "application/json",
@@ -278,13 +427,41 @@ export class KibanaClient {
                 },
                 ...(options.body === undefined ? {} : { body: JSON.stringify(options.body) }),
             });
+            phase = "response";
             if (!response.ok) {
                 const errorBody = await response.text();
                 throw new KibanaHttpError(response.status, errorBody);
             }
-            return response.json();
+            return await response.json();
+        }
+        catch (error) {
+            const sourceLabel = options.sourceId ? ` for source '${options.sourceId}'` : "";
+            if (error instanceof KibanaRequestError) {
+                throw error;
+            }
+            if (options.callerSignal?.aborted) {
+                throw new KibanaRequestError("KIBANA_CANCELLED", phase, options.sourceId, this.config.timeoutMs, `[KIBANA_CANCELLED] Kibana request${sourceLabel} was cancelled during ${phase}`, error);
+            }
+            if (error instanceof RequestQueueFullError) {
+                throw new KibanaRequestError("KIBANA_OVERLOADED", "queue", options.sourceId, this.queueTimeoutMs, `[KIBANA_OVERLOADED] Kibana request queue${sourceLabel} is full (${error.maxQueueDepth} waiting requests)`, error);
+            }
+            if (queueController.signal.aborted) {
+                throw new KibanaRequestError("KIBANA_TIMEOUT", "queue", options.sourceId, this.queueTimeoutMs, `[KIBANA_TIMEOUT] Kibana request${sourceLabel} exceeded the ${this.queueTimeoutMs}ms queue-wait timeout`, error);
+            }
+            if (timeoutController.signal.aborted) {
+                throw new KibanaRequestError("KIBANA_TIMEOUT", phase, options.sourceId, this.config.timeoutMs, `[KIBANA_TIMEOUT] Kibana request${sourceLabel} timed out after ${this.config.timeoutMs}ms during ${phase}`, error);
+            }
+            if (error instanceof KibanaHttpError) {
+                const code = error.status === 401 || error.status === 403 ? "KIBANA_AUTHENTICATION" : "KIBANA_HTTP";
+                throw new KibanaRequestError(code, "response", options.sourceId, this.config.timeoutMs, `[${code}] Kibana request${sourceLabel} returned HTTP ${error.status}`, error, error.status);
+            }
+            const causeCode = getNetworkCauseCode(error);
+            const code = phase === "response" && !causeCode ? "KIBANA_RESPONSE" : classifyNetworkError(causeCode);
+            throw new KibanaRequestError(code, phase, options.sourceId, this.config.timeoutMs, `[${code}] Kibana request${sourceLabel} failed during ${phase}${causeCode ? ` (${causeCode})` : ""}`, error, undefined, causeCode);
         }
         finally {
+            release?.();
+            clearTimeout(queueTimeout);
             clearTimeout(timeout);
         }
     }
@@ -296,101 +473,88 @@ export class KibanaClient {
             throw new Error("Kibana connection verification did not return a valid Kibana status response.");
         }
     }
-    async execute(compiledQuery) {
+    async execute(compiledQuery, callerSignal) {
         const source = compiledQuery.source;
         const endpoint = joinUrl(this.config.baseUrl, source.backend.path);
-        const controller = new AbortController();
-        const timeout = setTimeout(() => controller.abort(), this.config.timeoutMs);
-        try {
-            const body = source.backend.kind === "kibana_internal_search_es"
-                ? {
-                    params: {
-                        ...(source.backend.index ? { index: source.backend.index } : {}),
-                        body: compiledQuery.request.body,
-                    },
-                }
-                : compiledQuery.request.body;
-            const response = await fetch(endpoint, {
-                method: "POST",
-                signal: controller.signal,
-                headers: {
-                    Authorization: `Basic ${encodeBasicAuth(this.config.username, this.config.password)}`,
-                    "Content-Type": "application/json",
-                    ...(source.backend.kind === "kibana_internal_search_es"
-                        ? { "kbn-xsrf": "kibana-mcp-server" }
-                        : {}),
+        const body = source.backend.kind === "kibana_internal_search_es"
+            ? {
+                params: {
+                    ...(source.backend.index ? { index: source.backend.index } : {}),
+                    body: compiledQuery.request.body,
                 },
-                body: JSON.stringify(body),
-            });
-            if (!response.ok) {
-                const errorBody = await response.text();
-                throw new Error(`Kibana request failed for source '${source.id}' with status ${response.status}: ${errorBody}`);
             }
-            const responseJson = (await response.json());
+            : compiledQuery.request.body;
+        const responseJson = await this.requestJson(endpoint, {
+            method: "POST",
+            callerSignal,
+            sourceId: source.id,
+            headers: source.backend.kind === "kibana_internal_search_es"
+                ? { "kbn-xsrf": "kibana-mcp-server" }
+                : undefined,
+            body,
+        });
+        try {
             return {
                 source,
                 rawResponse: unwrapSearchResponse(responseJson),
             };
         }
-        finally {
-            clearTimeout(timeout);
+        catch (error) {
+            throw new KibanaRequestError("KIBANA_RESPONSE", "response", source.id, this.config.timeoutMs, `[KIBANA_RESPONSE] Kibana returned an unexpected search response for source '${source.id}'`, error);
         }
     }
-    async executeMany(sourceQueries) {
-        return Promise.all(sourceQueries.map((sourceQuery) => this.execute(sourceQuery)));
+    async executeMany(sourceQueries, callerSignal) {
+        const siblingController = new AbortController();
+        const signal = callerSignal
+            ? AbortSignal.any([callerSignal, siblingController.signal])
+            : siblingController.signal;
+        const executions = sourceQueries.map((sourceQuery) => this.execute(sourceQuery, signal));
+        try {
+            return await Promise.all(executions);
+        }
+        catch (error) {
+            siblingController.abort(error);
+            await Promise.allSettled(executions);
+            throw error;
+        }
     }
-    async describeFieldsViaSearchBackend(source) {
+    async describeFieldsViaSearchBackend(source, callerSignal) {
         const endpoint = joinUrl(this.config.baseUrl, source.backend.path);
-        const controller = new AbortController();
-        const timeout = setTimeout(() => controller.abort(), this.config.timeoutMs);
-        try {
-            const body = source.backend.kind === "kibana_internal_search_es"
-                ? {
-                    params: {
-                        ...(source.backend.index ? { index: source.backend.index } : {}),
-                        body: {
-                            size: 20,
-                            fields: ["*"],
-                            _source: true,
-                            track_total_hits: false,
-                        },
+        const body = source.backend.kind === "kibana_internal_search_es"
+            ? {
+                params: {
+                    ...(source.backend.index ? { index: source.backend.index } : {}),
+                    body: {
+                        size: 20,
+                        fields: ["*"],
+                        _source: true,
+                        track_total_hits: false,
                     },
-                }
-                : {
-                    size: 20,
-                    fields: ["*"],
-                    _source: true,
-                    track_total_hits: false,
-                };
-            const response = await fetch(endpoint, {
-                method: "POST",
-                signal: controller.signal,
-                headers: {
-                    Authorization: `Basic ${encodeBasicAuth(this.config.username, this.config.password)}`,
-                    "Content-Type": "application/json",
-                    ...(source.backend.kind === "kibana_internal_search_es"
-                        ? { "kbn-xsrf": "kibana-mcp-server" }
-                        : {}),
                 },
-                body: JSON.stringify(body),
-            });
-            if (!response.ok) {
-                const errorBody = await response.text();
-                throw new Error(`Search transport fallback failed for source '${source.id}' with status ${response.status}: ${errorBody}`);
-            }
-            const responseJson = (await response.json());
-            const rawResponse = unwrapSearchResponse(responseJson);
-            const fields = normalizeSearchSampleFields(rawResponse);
-            if (fields.length === 0) {
-                throw new Error(`Search transport fallback returned no fields for source '${source.id}'. Sample hits may be empty for the requested index pattern.`);
             }
-            return fields;
-        }
-        finally {
-            clearTimeout(timeout);
+            : {
+                size: 20,
+                fields: ["*"],
+                _source: true,
+                track_total_hits: false,
+            };
+        const responseJson = await this.requestJson(endpoint, {
+            method: "POST",
+            callerSignal,
+            sourceId: source.id,
+            headers: source.backend.kind === "kibana_internal_search_es"
+                ? { "kbn-xsrf": "kibana-mcp-server" }
+                : undefined,
+            body,
+        });
+        const rawResponse = unwrapSearchResponse(responseJson);
+        const fields = normalizeSearchSampleFields(rawResponse);
+        if (fields.length === 0) {
+            throw new KibanaRequestError("KIBANA_RESPONSE", "response", source.id, this.config.timeoutMs, `[KIBANA_RESPONSE] Search transport fallback returned no fields for source '${source.id}'. Sample hits may be empty for the requested index pattern.`);
         }
+        return fields;
     }
-    async describeFields(source) {
+    async describeFields(source, callerSignal) {
         const schemaBackend = source.schema;
         if (!schemaBackend) {
             throw new Error(`Source '${source.id}' does not configure a schema backend. Add source.schema before using describe_fields or schema-dependent query features.`);
@@ -408,16 +572,21 @@ export class KibanaClient {
             try {
                 responseJson = await this.requestJson(url, {
                     method: "GET",
+                    callerSignal,
+                    sourceId: source.id,
                 });
             }
             catch (error) {
+                if (error instanceof KibanaRequestError) {
+                    throw error;
+                }
                 throw new Error(`Schema backend '${schemaBackend.kind}' request failed for source '${source.id}' at '${schemaPath}': ${error instanceof Error ? error.message : String(error)}`);
             }
             try {
                 return normalizeFieldCapsResponse(responseJson);
             }
             catch (error) {
-                throw new Error(`Schema backend '${schemaBackend.kind}' returned an unexpected field capabilities payload for source '${source.id}': ${error instanceof Error ? error.message : String(error)}`);
+                throw new KibanaRequestError("KIBANA_RESPONSE", "response", source.id, this.config.timeoutMs, `[KIBANA_RESPONSE] Schema backend '${schemaBackend.kind}' returned an unexpected field capabilities payload for source '${source.id}': ${error instanceof Error ? error.message : String(error)}`, error);
             }
         }
         const attempts = [];
@@ -426,6 +595,8 @@ export class KibanaClient {
             try {
                 const responseJson = await this.requestJson(url, {
                     method: "GET",
+                    callerSignal,
+                    sourceId: source.id,
                     headers: {
                         "kbn-xsrf": "kibana-mcp-server",
                     },
@@ -434,18 +605,24 @@ export class KibanaClient {
                     return normalizeKibanaFieldsResponse(responseJson);
                 }
                 catch (error) {
-                    throw new Error(`Schema backend '${schemaBackend.kind}' returned an unexpected Kibana field payload for source '${source.id}' from '${schemaPath}': ${error instanceof Error ? error.message : String(error)}`);
+                    throw new KibanaRequestError("KIBANA_RESPONSE", "response", source.id, this.config.timeoutMs, `[KIBANA_RESPONSE] Schema backend '${schemaBackend.kind}' returned an unexpected Kibana field payload for source '${source.id}' from '${schemaPath}': ${error instanceof Error ? error.message : String(error)}`, error);
                 }
             }
             catch (error) {
-                if (error instanceof KibanaHttpError && error.status === 404) {
+                if (error instanceof KibanaRequestError && error.status === 404) {
                     attempts.push(`${schemaPath} -> 404`);
                     continue;
                 }
+                if (error instanceof KibanaRequestError) {
+                    throw error;
+                }
                 throw new Error(`Schema backend '${schemaBackend.kind}' request failed for source '${source.id}' at '${schemaPath}': ${error instanceof Error ? error.message : String(error)}`);
             }
         }
-        return this.describeFieldsViaSearchBackend(source).catch((fallbackError) => {
+        return this.describeFieldsViaSearchBackend(source, callerSignal).catch((fallbackError) => {
+            if (fallbackError instanceof KibanaRequestError) {
+                throw fallbackError;
+            }
             throw new Error(`Schema backend '${schemaBackend.kind}' returned 404 for source '${source.id}' on every known Kibana field-discovery path (${attempts.join(", ")}). Search transport fallback also failed: ${fallbackError instanceof Error ? fallbackError.message : String(fallbackError)}`);
         });
     }

package/dist/src/schema_catalog.js

@@ -54,19 +54,33 @@ function mergeFieldHints(source, fields) {
 export class SchemaCatalog {
     client;
     cache = new Map();
+    inFlight = new Map();
     constructor(client) {
         this.client = client;
     }
-    async getFields(source) {
+    async getFields(source, callerSignal) {
         const existing = this.cache.get(source.id);
         if (existing) {
             return existing;
         }
-        const pending = this.client
-            .describeFields(source)
-            .then((fields) => linkFieldRelationships(mergeFieldHints(source, fields)));
-        this.cache.set(source.id, pending);
-        return pending;
+        const pending = this.inFlight.get(source.id);
+        if (pending) {
+            return pending;
+        }
+        const discovery = this.client.describeFields(source, callerSignal).then((fields) => {
+            const resolved = linkFieldRelationships(mergeFieldHints(source, fields));
+            this.cache.set(source.id, resolved);
+            return resolved;
+        });
+        this.inFlight.set(source.id, discovery);
+        try {
+            return await discovery;
+        }
+        finally {
+            if (this.inFlight.get(source.id) === discovery) {
+                this.inFlight.delete(source.id);
+            }
+        }
     }
     filterFields(fields, query, limit = 100) {
         const normalizedQuery = query ? normalizeFieldName(query) : undefined;

package/dist/src/server.js

@@ -1,5 +1,5 @@
 import { McpServer } from "@modelcontextprotocol/server";
-import { KibanaClient } from "./kibana_client.js";
+import { KibanaClient, KibanaRequestError } from "./kibana_client.js";
 import { SchemaCatalog } from "./schema_catalog.js";
 import { SourceCatalog } from "./source_catalog.js";
 import { configureInputSchema, configureOutputSchema, createConfigureCallToolResult, executeConfigure, } from "./tools/configure.js";
@@ -8,6 +8,30 @@ import { createDescribeFieldsCallToolResult, describeFieldsInputSchema, describe
 import { createDiscoverCallToolResult, discoverInputSchema, discoverOutputSchema, executeDiscover, } from "./tools/discover.js";
 import { createFilterCallToolResult, executeFilter, filterInputSchema, filterOutputSchema, } from "./tools/filter.js";
 import { createQueryCallToolResult, executeQuery, queryInputSchema, queryOutputSchema, } from "./tools/query.js";
+async function withKibanaRequestDiagnostics(operation) {
+    try {
+        return await operation();
+    }
+    catch (error) {
+        if (!(error instanceof KibanaRequestError)) {
+            throw error;
+        }
+        return {
+            content: [{ type: "text", text: error.message }],
+            isError: true,
+            _meta: {
+                kibana_request_error: {
+                    code: error.code,
+                    phase: error.phase,
+                    source_id: error.sourceId,
+                    timeout_ms: error.timeoutMs,
+                    ...(error.status === undefined ? {} : { status: error.status }),
+                    ...(error.causeCode === undefined ? {} : { cause_code: error.causeCode }),
+                },
+            },
+        };
+    }
+}
 export function createApplication(initialConfig, dependencies) {
     const server = new McpServer({
         name: "kibana-log-investigation",
@@ -21,6 +45,24 @@ export function createApplication(initialConfig, dependencies) {
         ? (dependencies?.kibanaClient ?? kibanaClientFactory(activeConfig.kibana))
         : null;
     let schemaCatalog = kibanaClient ? new SchemaCatalog(kibanaClient) : null;
+    async function withKibanaToolDeadline(callerSignal, operation) {
+        const timeoutMs = activeConfig?.kibana.timeoutMs;
+        if (timeoutMs === undefined) {
+            throw new Error("Server is not configured. Call the 'configure' tool first.");
+        }
+        const timeoutSignal = AbortSignal.timeout(timeoutMs);
+        const signal = callerSignal ? AbortSignal.any([callerSignal, timeoutSignal]) : timeoutSignal;
+        try {
+            return await operation(signal);
+        }
+        catch (error) {
+            if (callerSignal?.aborted || !timeoutSignal.aborted) {
+                throw error;
+            }
+            const requestError = error instanceof KibanaRequestError ? error : undefined;
+            throw new KibanaRequestError("KIBANA_TIMEOUT", requestError?.phase ?? "request", requestError?.sourceId, timeoutMs, `Kibana tool call exceeded its ${timeoutMs} ms backend deadline.`, error, requestError?.status, requestError?.causeCode);
+        }
+    }
     function requireConfigured() {
         if (!sourceCatalog || !kibanaClient || !schemaCatalog) {
             throw new Error("Server is not configured. Call the 'configure' tool first.");
@@ -42,28 +84,33 @@ export function createApplication(initialConfig, dependencies) {
         schemaCatalog = new SchemaCatalog(kibanaClient);
         return result;
     };
-    const configureIndexHandler = async (input) => {
+    const configureIndexHandler = async (input, callerSignal) => {
         if (!activeConfig || !kibanaClient) {
             throw new Error("No saved Kibana connection is available. Run connection bootstrap first.");
         }
+        const configured = activeConfig;
+        const client = kibanaClient;
         const configureIndexFn = dependencies?.configureIndexFn ?? executeConfigureIndex;
-        const { sources, result } = await configureIndexFn(configureIndexInputSchema.parse(input), {
-            config: activeConfig,
-            kibanaClient,
-        });
+        const { sources, result } = await withKibanaToolDeadline(callerSignal, (signal) => configureIndexFn(configureIndexInputSchema.parse(input), {
+            config: configured,
+            kibanaClient: client,
+            callerSignal: signal,
+        }));
         activeConfig = { ...activeConfig, sources };
         sourceCatalog = new SourceCatalog(sources);
-        schemaCatalog = new SchemaCatalog(kibanaClient);
+        schemaCatalog = new SchemaCatalog(client);
         return result;
     };
-    const describeFieldsHandler = (input) => executeDescribeFields(describeFieldsInputSchema.parse(input), requireConfigured().sourceCatalog, requireConfigured().schemaCatalog);
+    const describeFieldsHandler = (input, callerSignal) => withKibanaToolDeadline(callerSignal, (signal) => executeDescribeFields(describeFieldsInputSchema.parse(input), requireConfigured().sourceCatalog, requireConfigured().schemaCatalog, signal));
     const discoverHandler = (input) => executeDiscover(discoverInputSchema.parse(input), requireConfigured().sourceCatalog);
-    const filterHandler = (input) => executeFilter(filterInputSchema.parse(input), requireConfigured().sourceCatalog, requireConfigured().kibanaClient, {
+    const filterHandler = (input, callerSignal) => withKibanaToolDeadline(callerSignal, (signal) => executeFilter(filterInputSchema.parse(input), requireConfigured().sourceCatalog, requireConfigured().kibanaClient, {
         schemaCatalog: requireConfigured().schemaCatalog,
-    });
-    const queryHandler = (input) => executeQuery(queryInputSchema.parse(input), requireConfigured().sourceCatalog, requireConfigured().kibanaClient, {
+        callerSignal: signal,
+    }));
+    const queryHandler = (input, callerSignal) => withKibanaToolDeadline(callerSignal, (signal) => executeQuery(queryInputSchema.parse(input), requireConfigured().sourceCatalog, requireConfigured().kibanaClient, {
         schemaCatalog: requireConfigured().schemaCatalog,
-    });
+        callerSignal: signal,
+    }));
     if (!initialConfig) {
         server.registerTool("configure", {
             description: "Advanced legacy setup for a server started without a saved profile. Replaces the Kibana connection and full source catalog.",
@@ -76,13 +123,13 @@ export function createApplication(initialConfig, dependencies) {
             description: "Configure exactly one Kibana index or index pattern after the user has explicitly named it. Never guess, list, scan, or auto-select indexes before calling this tool.",
             inputSchema: configureIndexInputSchema,
             outputSchema: configureIndexOutputSchema,
-        }, async (input) => createConfigureIndexCallToolResult(await configureIndexHandler(input)));
+        }, async (input, context) => withKibanaRequestDiagnostics(async () => createConfigureIndexCallToolResult(await configureIndexHandler(input, context.mcpReq.signal))));
     }
     server.registerTool("describe_fields", {
         description: "Describe the effective field capabilities for a configured logical source.",
         inputSchema: describeFieldsInputSchema,
         outputSchema: describeFieldsOutputSchema,
-    }, async (input) => createDescribeFieldsCallToolResult(await describeFieldsHandler(input)));
+    }, async (input, context) => withKibanaRequestDiagnostics(async () => createDescribeFieldsCallToolResult(await describeFieldsHandler(input, context.mcpReq.signal))));
     server.registerTool("discover", {
         description: "List configured logical log sources and field hints for investigation work.",
         inputSchema: discoverInputSchema,
@@ -92,12 +139,12 @@ export function createApplication(initialConfig, dependencies) {
         description: "Run an exact-field filter when the field name is already known, bypassing alias resolution.",
         inputSchema: filterInputSchema,
         outputSchema: filterOutputSchema,
-    }, async (input) => createFilterCallToolResult(await filterHandler(input)));
+    }, async (input, context) => withKibanaRequestDiagnostics(async () => createFilterCallToolResult(await filterHandler(input, context.mcpReq.signal))));
     server.registerTool("query", {
         description: "Query one or more logical log sources over an absolute time window with text, filters, and aggregate modes.",
         inputSchema: queryInputSchema,
         outputSchema: queryOutputSchema,
-    }, async (input) => createQueryCallToolResult(await queryHandler(input)));
+    }, async (input, context) => withKibanaRequestDiagnostics(async () => createQueryCallToolResult(await queryHandler(input, context.mcpReq.signal))));
     return {
         server,
         handlers: {