@structured-world/gitlab-mcp 6.62.1 → 7.0.1

package/dist/src/registry-manager.js

@@ -22,16 +22,19 @@ const registry_18 = require("./entities/iterations/registry");
 const config_1 = require("./config");
 const ToolAvailability_1 = require("./services/ToolAvailability");
 const ConnectionManager_1 = require("./services/ConnectionManager");
+const HealthMonitor_1 = require("./services/HealthMonitor");
 const TokenScopeDetector_1 = require("./services/TokenScopeDetector");
 const logger_1 = require("./logger");
 const schema_utils_1 = require("./utils/schema-utils");
 const description_utils_1 = require("./utils/description-utils");
+const url_1 = require("./utils/url");
+const token_context_1 = require("./oauth/token-context");
 class RegistryManager {
     static instance;
     registries = new Map();
-    toolLookupCache = new Map();
-    toolDefinitionsCache = null;
-    toolNamesCache = null;
+    toolLookupCaches = new Map();
+    toolDefinitionsCaches = new Map();
+    toolNamesCaches = new Map();
     descriptionOverrides = new Map();
     readOnlyToolsCache = null;
     constructor() {
@@ -46,63 +49,63 @@ class RegistryManager {
         return RegistryManager.instance;
     }
     initializeRegistries() {
-        this.registries.set("core", registry_1.coreToolRegistry);
-        this.registries.set("context", registry_17.contextToolRegistry);
+        this.registries.set('core', registry_1.coreToolRegistry);
+        this.registries.set('context', registry_17.contextToolRegistry);
         if (config_1.USE_LABELS) {
-            this.registries.set("labels", registry_2.labelsToolRegistry);
+            this.registries.set('labels', registry_2.labelsToolRegistry);
         }
         if (config_1.USE_MRS) {
-            this.registries.set("mrs", registry_3.mrsToolRegistry);
+            this.registries.set('mrs', registry_3.mrsToolRegistry);
         }
         if (config_1.USE_FILES) {
-            this.registries.set("files", registry_4.filesToolRegistry);
+            this.registries.set('files', registry_4.filesToolRegistry);
         }
         if (config_1.USE_MILESTONE) {
-            this.registries.set("milestones", registry_5.milestonesToolRegistry);
+            this.registries.set('milestones', registry_5.milestonesToolRegistry);
         }
         if (config_1.USE_PIPELINE) {
-            this.registries.set("pipelines", registry_6.pipelinesToolRegistry);
+            this.registries.set('pipelines', registry_6.pipelinesToolRegistry);
         }
         if (config_1.USE_VARIABLES) {
-            this.registries.set("variables", registry_7.variablesToolRegistry);
+            this.registries.set('variables', registry_7.variablesToolRegistry);
         }
         if (config_1.USE_GITLAB_WIKI) {
-            this.registries.set("wiki", registry_8.wikiToolRegistry);
+            this.registries.set('wiki', registry_8.wikiToolRegistry);
         }
         if (config_1.USE_WORKITEMS) {
-            this.registries.set("workitems", registry_9.workitemsToolRegistry);
+            this.registries.set('workitems', registry_9.workitemsToolRegistry);
         }
         if (config_1.USE_SNIPPETS) {
-            this.registries.set("snippets", registry_11.snippetsToolRegistry);
+            this.registries.set('snippets', registry_11.snippetsToolRegistry);
         }
         if (config_1.USE_WEBHOOKS) {
-            this.registries.set("webhooks", registry_10.webhooksToolRegistry);
+            this.registries.set('webhooks', registry_10.webhooksToolRegistry);
         }
         if (config_1.USE_INTEGRATIONS) {
-            this.registries.set("integrations", registry_12.integrationsToolRegistry);
+            this.registries.set('integrations', registry_12.integrationsToolRegistry);
         }
         if (config_1.USE_RELEASES) {
-            this.registries.set("releases", registry_13.releasesToolRegistry);
+            this.registries.set('releases', registry_13.releasesToolRegistry);
         }
         if (config_1.USE_REFS) {
-            this.registries.set("refs", registry_14.refsToolRegistry);
+            this.registries.set('refs', registry_14.refsToolRegistry);
         }
         if (config_1.USE_MEMBERS) {
-            this.registries.set("members", registry_15.membersToolRegistry);
+            this.registries.set('members', registry_15.membersToolRegistry);
         }
         if (config_1.USE_SEARCH) {
-            this.registries.set("search", registry_16.searchToolRegistry);
+            this.registries.set('search', registry_16.searchToolRegistry);
         }
         if (config_1.USE_ITERATIONS) {
-            this.registries.set("iterations", registry_18.iterationsToolRegistry);
+            this.registries.set('iterations', registry_18.iterationsToolRegistry);
         }
     }
     loadDescriptionOverrides() {
         this.descriptionOverrides = (0, config_1.getToolDescriptionOverrides)();
         if (this.descriptionOverrides.size > 0) {
-            (0, logger_1.logDebug)("Loaded tool description overrides", { count: this.descriptionOverrides.size });
+            (0, logger_1.logDebug)('Loaded tool description overrides', { count: this.descriptionOverrides.size });
             for (const [toolName, description] of this.descriptionOverrides) {
-                (0, logger_1.logDebug)("Tool description override", { toolName, description });
+                (0, logger_1.logDebug)('Tool description override', { toolName, description });
             }
         }
     }
@@ -164,51 +167,73 @@ class RegistryManager {
         this.readOnlyToolsCache ??= this.buildReadOnlyToolsList();
         return this.readOnlyToolsCache;
     }
-    buildToolLookupCache() {
-        this.toolLookupCache.clear();
+    loadInstanceContext(instanceUrl) {
         let instanceInfo;
         try {
-            const info = ConnectionManager_1.ConnectionManager.getInstance().getInstanceInfo();
+            const info = ConnectionManager_1.ConnectionManager.getInstance().getInstanceInfo(instanceUrl);
             instanceInfo = { tier: info.tier, version: info.version };
         }
-        catch {
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            if (!msg.includes('not initialized') &&
+                !msg.includes('not available') &&
+                !msg.includes('No connection')) {
+                (0, logger_1.logWarn)('Unexpected error loading instance info for tool cache', {
+                    error: msg,
+                    instanceUrl,
+                });
+            }
         }
         let tokenScopes;
         try {
-            const scopeInfo = ConnectionManager_1.ConnectionManager.getInstance().getTokenScopeInfo();
+            const scopeInfo = ConnectionManager_1.ConnectionManager.getInstance().getTokenScopeInfo(instanceUrl);
             if (scopeInfo) {
                 tokenScopes = scopeInfo.scopes;
             }
         }
-        catch {
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            if (!msg.includes('not initialized') &&
+                !msg.includes('not available') &&
+                !msg.includes('No connection')) {
+                (0, logger_1.logWarn)('Unexpected error loading token scopes for tool cache', {
+                    error: msg,
+                    instanceUrl,
+                });
+            }
         }
-        for (const registry of this.registries.values()) {
+        return { instanceInfo, tokenScopes };
+    }
+    getToolExclusionReason(toolName, tool, ctx) {
+        if (config_1.GITLAB_READ_ONLY_MODE && !this.getReadOnlyTools().includes(toolName))
+            return 'readOnly';
+        if (config_1.GITLAB_DENIED_TOOLS_REGEX?.test(toolName))
+            return 'deniedRegex';
+        if (ctx.tokenScopes && !(0, TokenScopeDetector_1.isToolAvailableForScopes)(toolName, ctx.tokenScopes))
+            return 'scopes';
+        const isContextTool = this.registries.get('context')?.has(toolName) ?? false;
+        if (!isContextTool &&
+            ctx.instanceInfo &&
+            ctx.instanceInfo.version !== 'unknown' &&
+            !ToolAvailability_1.ToolAvailability.isToolAvailableForInstance(toolName, ctx.instanceInfo))
+            return 'tier';
+        const allActions = (0, schema_utils_1.extractActionsFromSchema)(tool.inputSchema);
+        if (allActions.length > 0 && (0, schema_utils_1.shouldRemoveTool)(toolName, allActions))
+            return 'actionDenial';
+        return null;
+    }
+    buildFilteredTools(ctx) {
+        const result = new Map();
+        for (const [, registry] of this.registries) {
             for (const [toolName, tool] of registry) {
-                if (config_1.GITLAB_READ_ONLY_MODE && !this.getReadOnlyTools().includes(toolName)) {
-                    (0, logger_1.logDebug)("Tool filtered out: read-only mode", { toolName });
-                    continue;
-                }
-                if (config_1.GITLAB_DENIED_TOOLS_REGEX?.test(toolName)) {
-                    (0, logger_1.logDebug)("Tool filtered out: matches denied regex", { toolName });
-                    continue;
-                }
-                if (tokenScopes && !(0, TokenScopeDetector_1.isToolAvailableForScopes)(toolName, tokenScopes)) {
-                    (0, logger_1.logDebug)("Tool filtered out: insufficient token scopes", { toolName });
-                    continue;
-                }
-                if (!ToolAvailability_1.ToolAvailability.isToolAvailable(toolName)) {
-                    const reason = ToolAvailability_1.ToolAvailability.getUnavailableReason(toolName);
-                    (0, logger_1.logDebug)("Tool filtered out", { toolName, reason });
-                    continue;
-                }
-                const allActions = (0, schema_utils_1.extractActionsFromSchema)(tool.inputSchema);
-                if (allActions.length > 0 && (0, schema_utils_1.shouldRemoveTool)(toolName, allActions)) {
-                    (0, logger_1.logDebug)("Tool filtered out: all actions denied", { toolName });
+                const exclusion = this.getToolExclusionReason(toolName, tool, ctx);
+                if (exclusion) {
+                    (0, logger_1.logDebug)('Tool filtered out', { toolName, reason: exclusion });
                     continue;
                 }
                 let transformedSchema = (0, schema_utils_1.transformToolSchema)(toolName, tool.inputSchema);
-                if (instanceInfo) {
-                    const restrictedParams = ToolAvailability_1.ToolAvailability.getRestrictedParameters(toolName, instanceInfo);
+                if (ctx.instanceInfo && ctx.instanceInfo.version !== 'unknown') {
+                    const restrictedParams = ToolAvailability_1.ToolAvailability.getRestrictedParameters(toolName, ctx.instanceInfo);
                     if (restrictedParams.length > 0) {
                         transformedSchema = (0, schema_utils_1.stripTierRestrictedParameters)(transformedSchema, restrictedParams);
                     }
@@ -220,125 +245,162 @@ class RegistryManager {
                     ...(customDescription && { description: customDescription }),
                 };
                 if (customDescription) {
-                    (0, logger_1.logDebug)("Applied description override", { toolName, customDescription });
+                    (0, logger_1.logDebug)('Applied description override', { toolName, customDescription });
                 }
-                this.toolLookupCache.set(toolName, finalTool);
+                result.set(toolName, finalTool);
             }
         }
-        if (config_1.GITLAB_CROSS_REFS) {
-            const availableToolNames = new Set(this.toolLookupCache.keys());
-            for (const [toolName, tool] of this.toolLookupCache) {
-                if (this.descriptionOverrides.has(toolName))
-                    continue;
-                const resolved = (0, description_utils_1.resolveRelatedReferences)(tool.description, availableToolNames);
-                if (resolved !== tool.description) {
-                    this.toolLookupCache.set(toolName, { ...tool, description: resolved });
-                }
+        return result;
+    }
+    postProcessRelatedReferences(cache) {
+        const availableToolNames = config_1.GITLAB_CROSS_REFS ? new Set(cache.keys()) : undefined;
+        for (const [toolName, tool] of cache) {
+            if (this.descriptionOverrides.has(toolName))
+                continue;
+            const nextDescription = availableToolNames
+                ? (0, description_utils_1.resolveRelatedReferences)(tool.description, availableToolNames)
+                : (0, description_utils_1.stripRelatedSection)(tool.description);
+            if (nextDescription !== tool.description) {
+                cache.set(toolName, { ...tool, description: nextDescription });
             }
         }
-        else {
-            for (const [toolName, tool] of this.toolLookupCache) {
-                if (this.descriptionOverrides.has(toolName))
-                    continue;
-                const stripped = (0, description_utils_1.stripRelatedSection)(tool.description);
-                if (stripped !== tool.description) {
-                    this.toolLookupCache.set(toolName, { ...tool, description: stripped });
-                }
-            }
+    }
+    resolveCacheUrl(instanceUrl) {
+        if (instanceUrl)
+            return (0, url_1.normalizeInstanceUrl)(instanceUrl);
+        const contextUrl = (0, token_context_1.getGitLabApiUrlFromContext)();
+        if (contextUrl)
+            return (0, url_1.normalizeInstanceUrl)(contextUrl);
+        try {
+            const current = ConnectionManager_1.ConnectionManager.getInstance().getCurrentInstanceUrl();
+            if (current)
+                return (0, url_1.normalizeInstanceUrl)(current);
+        }
+        catch {
         }
-        (0, logger_1.logDebug)("Registry manager built cache after filtering", {
-            toolCount: this.toolLookupCache.size,
+        return (0, url_1.normalizeInstanceUrl)(config_1.GITLAB_BASE_URL);
+    }
+    resolveCache(instanceUrl) {
+        const url = this.resolveCacheUrl(instanceUrl);
+        let cache = this.toolLookupCaches.get(url);
+        if (!cache) {
+            this.buildToolLookupCache(url);
+            cache = this.toolLookupCaches.get(url);
+        }
+        return cache ?? new Map();
+    }
+    buildToolLookupCache(instanceUrl) {
+        const url = this.resolveCacheUrl(instanceUrl);
+        const ctx = this.loadInstanceContext(url);
+        const newCache = this.buildFilteredTools(ctx);
+        this.postProcessRelatedReferences(newCache);
+        this.toolLookupCaches.set(url, newCache);
+        (0, logger_1.logDebug)('Registry manager built cache after filtering', {
+            toolCount: newCache.size,
+            instanceUrl: url,
         });
     }
-    invalidateCaches() {
-        this.toolDefinitionsCache = null;
-        this.toolNamesCache = null;
-        this.readOnlyToolsCache = null;
-        this.buildToolLookupCache();
+    invalidateCaches(instanceUrl) {
+        const url = this.resolveCacheUrl(instanceUrl);
+        this.toolDefinitionsCaches.delete(url);
+        this.toolNamesCaches.delete(url);
+        this.buildToolLookupCache(url);
     }
-    getTool(toolName) {
-        return this.toolLookupCache.get(toolName) ?? null;
+    getTool(toolName, instanceUrl) {
+        return this.resolveCache(instanceUrl).get(toolName) ?? null;
     }
-    async executeTool(toolName, args) {
-        const tool = this.getTool(toolName);
+    async executeTool(toolName, args, instanceUrl) {
+        const tool = this.getTool(toolName, instanceUrl);
         if (!tool) {
             throw new Error(`Tool '${toolName}' not found in any registry`);
         }
         return await tool.handler(args);
     }
-    refreshCache() {
-        this.invalidateCaches();
+    refreshCache(instanceUrl) {
+        this.invalidateCaches(instanceUrl);
     }
-    getAllToolDefinitions() {
-        if (this.toolDefinitionsCache === null) {
-            this.toolDefinitionsCache = [];
-            for (const tool of this.toolLookupCache.values()) {
-                this.toolDefinitionsCache.push({
+    getAllToolDefinitions(instanceUrl) {
+        const url = this.resolveCacheUrl(instanceUrl);
+        const cache = this.resolveCache(instanceUrl);
+        const unreachableMode = this.isUnreachableFor(instanceUrl);
+        const cachedDefs = this.toolDefinitionsCaches.get(url);
+        if (cachedDefs === undefined || unreachableMode) {
+            const contextTools = unreachableMode ? this.registries.get('context') : null;
+            const defs = [];
+            for (const tool of cache.values()) {
+                if (contextTools && !contextTools.has(tool.name))
+                    continue;
+                defs.push({
                     name: tool.name,
                     description: tool.description,
                     inputSchema: tool.inputSchema,
                 });
             }
+            if (unreachableMode) {
+                return defs;
+            }
+            this.toolDefinitionsCaches.set(url, defs);
+            return defs;
         }
-        return this.toolDefinitionsCache;
+        return cachedDefs;
     }
     getAllToolDefinitionsTierless() {
         const allTools = [];
-        const isReadOnly = process.env.GITLAB_READ_ONLY_MODE === "true";
+        const isReadOnly = process.env.GITLAB_READ_ONLY_MODE === 'true';
         const deniedRegex = process.env.GITLAB_DENIED_TOOLS_REGEX
             ? new RegExp(process.env.GITLAB_DENIED_TOOLS_REGEX)
             : undefined;
-        const useLabels = process.env.USE_LABELS !== "false";
-        const useMrs = process.env.USE_MRS !== "false";
-        const useFiles = process.env.USE_FILES !== "false";
-        const useMilestone = process.env.USE_MILESTONE !== "false";
-        const usePipeline = process.env.USE_PIPELINE !== "false";
-        const useVariables = process.env.USE_VARIABLES !== "false";
-        const useWiki = process.env.USE_GITLAB_WIKI !== "false";
-        const useWorkitems = process.env.USE_WORKITEMS !== "false";
-        const useSnippets = process.env.USE_SNIPPETS !== "false";
-        const useWebhooks = process.env.USE_WEBHOOKS !== "false";
-        const useIntegrations = process.env.USE_INTEGRATIONS !== "false";
-        const useReleases = process.env.USE_RELEASES !== "false";
-        const useRefs = process.env.USE_REFS !== "false";
-        const useMembers = process.env.USE_MEMBERS !== "false";
-        const useSearch = process.env.USE_SEARCH !== "false";
-        const useIterations = process.env.USE_ITERATIONS !== "false";
+        const useLabels = process.env.USE_LABELS !== 'false';
+        const useMrs = process.env.USE_MRS !== 'false';
+        const useFiles = process.env.USE_FILES !== 'false';
+        const useMilestone = process.env.USE_MILESTONE !== 'false';
+        const usePipeline = process.env.USE_PIPELINE !== 'false';
+        const useVariables = process.env.USE_VARIABLES !== 'false';
+        const useWiki = process.env.USE_GITLAB_WIKI !== 'false';
+        const useWorkitems = process.env.USE_WORKITEMS !== 'false';
+        const useSnippets = process.env.USE_SNIPPETS !== 'false';
+        const useWebhooks = process.env.USE_WEBHOOKS !== 'false';
+        const useIntegrations = process.env.USE_INTEGRATIONS !== 'false';
+        const useReleases = process.env.USE_RELEASES !== 'false';
+        const useRefs = process.env.USE_REFS !== 'false';
+        const useMembers = process.env.USE_MEMBERS !== 'false';
+        const useSearch = process.env.USE_SEARCH !== 'false';
+        const useIterations = process.env.USE_ITERATIONS !== 'false';
         const registriesToUse = new Map();
-        registriesToUse.set("core", registry_1.coreToolRegistry);
-        registriesToUse.set("context", registry_17.contextToolRegistry);
+        registriesToUse.set('core', registry_1.coreToolRegistry);
+        registriesToUse.set('context', registry_17.contextToolRegistry);
         if (useLabels)
-            registriesToUse.set("labels", registry_2.labelsToolRegistry);
+            registriesToUse.set('labels', registry_2.labelsToolRegistry);
         if (useMrs)
-            registriesToUse.set("mrs", registry_3.mrsToolRegistry);
+            registriesToUse.set('mrs', registry_3.mrsToolRegistry);
         if (useFiles)
-            registriesToUse.set("files", registry_4.filesToolRegistry);
+            registriesToUse.set('files', registry_4.filesToolRegistry);
         if (useMilestone)
-            registriesToUse.set("milestones", registry_5.milestonesToolRegistry);
+            registriesToUse.set('milestones', registry_5.milestonesToolRegistry);
         if (usePipeline)
-            registriesToUse.set("pipelines", registry_6.pipelinesToolRegistry);
+            registriesToUse.set('pipelines', registry_6.pipelinesToolRegistry);
         if (useVariables)
-            registriesToUse.set("variables", registry_7.variablesToolRegistry);
+            registriesToUse.set('variables', registry_7.variablesToolRegistry);
         if (useWiki)
-            registriesToUse.set("wiki", registry_8.wikiToolRegistry);
+            registriesToUse.set('wiki', registry_8.wikiToolRegistry);
         if (useWorkitems)
-            registriesToUse.set("workitems", registry_9.workitemsToolRegistry);
+            registriesToUse.set('workitems', registry_9.workitemsToolRegistry);
         if (useSnippets)
-            registriesToUse.set("snippets", registry_11.snippetsToolRegistry);
+            registriesToUse.set('snippets', registry_11.snippetsToolRegistry);
         if (useWebhooks)
-            registriesToUse.set("webhooks", registry_10.webhooksToolRegistry);
+            registriesToUse.set('webhooks', registry_10.webhooksToolRegistry);
         if (useIntegrations)
-            registriesToUse.set("integrations", registry_12.integrationsToolRegistry);
+            registriesToUse.set('integrations', registry_12.integrationsToolRegistry);
         if (useReleases)
-            registriesToUse.set("releases", registry_13.releasesToolRegistry);
+            registriesToUse.set('releases', registry_13.releasesToolRegistry);
         if (useRefs)
-            registriesToUse.set("refs", registry_14.refsToolRegistry);
+            registriesToUse.set('refs', registry_14.refsToolRegistry);
         if (useMembers)
-            registriesToUse.set("members", registry_15.membersToolRegistry);
+            registriesToUse.set('members', registry_15.membersToolRegistry);
         if (useSearch)
-            registriesToUse.set("search", registry_16.searchToolRegistry);
+            registriesToUse.set('search', registry_16.searchToolRegistry);
         if (useIterations)
-            registriesToUse.set("iterations", registry_18.iterationsToolRegistry);
+            registriesToUse.set('iterations', registry_18.iterationsToolRegistry);
         const descOverrides = (0, config_1.getToolDescriptionOverrides)();
         for (const registry of registriesToUse.values()) {
             for (const [toolName, tool] of registry) {
@@ -362,9 +424,9 @@ class RegistryManager {
                 allTools.push(finalTool);
             }
         }
-        const crossRefsEnabled = process.env.GITLAB_CROSS_REFS !== "false";
+        const crossRefsEnabled = process.env.GITLAB_CROSS_REFS !== 'false';
         if (crossRefsEnabled) {
-            const availableToolNames = new Set(allTools.map(t => t.name));
+            const availableToolNames = new Set(allTools.map((t) => t.name));
             for (let i = 0; i < allTools.length; i++) {
                 const tool = allTools[i];
                 if (descOverrides.has(tool.name))
@@ -417,62 +479,85 @@ class RegistryManager {
         }
         return allTools;
     }
-    hasToolHandler(toolName) {
-        return this.toolLookupCache.has(toolName);
+    hasToolHandler(toolName, instanceUrl) {
+        return this.resolveCache(instanceUrl).has(toolName);
     }
-    getAvailableToolNames() {
-        this.toolNamesCache ??= Array.from(this.toolLookupCache.keys());
-        return this.toolNamesCache;
-    }
-    getFilterStats() {
-        let totalTools = 0;
-        for (const registry of this.registries.values()) {
-            totalTools += registry.size;
-        }
-        const availableTools = this.toolLookupCache.size;
-        let filteredByReadOnly = 0;
-        let filteredByDeniedRegex = 0;
-        let filteredByScopes = 0;
-        let filteredByTier = 0;
-        let filteredByActionDenial = 0;
-        let tokenScopes;
-        try {
-            const scopeInfo = ConnectionManager_1.ConnectionManager.getInstance().getTokenScopeInfo();
-            if (scopeInfo) {
-                tokenScopes = scopeInfo.scopes;
+    getAvailableToolNames(instanceUrl) {
+        const url = this.resolveCacheUrl(instanceUrl);
+        const cache = this.resolveCache(instanceUrl);
+        const unreachableMode = this.isUnreachableFor(instanceUrl);
+        const cachedNames = this.toolNamesCaches.get(url);
+        if (cachedNames === undefined || unreachableMode) {
+            const contextTools = unreachableMode ? this.registries.get('context') : null;
+            const names = Array.from(cache.keys()).filter((name) => !contextTools || contextTools.has(name));
+            if (unreachableMode) {
+                return names;
             }
+            this.toolNamesCaches.set(url, names);
+            return names;
         }
-        catch {
+        return cachedNames;
+    }
+    isUnreachableFor(instanceUrl) {
+        const healthMonitor = HealthMonitor_1.HealthMonitor.getInstance();
+        if (instanceUrl) {
+            try {
+                return (!healthMonitor.isInstanceReachable(instanceUrl) &&
+                    healthMonitor.getState(instanceUrl) !== 'connecting');
+            }
+            catch {
+                return false;
+            }
         }
+        return (healthMonitor.getMonitoredInstances().length > 0 && !healthMonitor.isAnyInstanceHealthy());
+    }
+    aggregateFilterCounters(ctx, contextTools) {
+        const counts = {
+            available: 0,
+            byReadOnly: 0,
+            byDeniedRegex: 0,
+            byScopes: 0,
+            byTier: 0,
+            byActionDenial: 0,
+        };
+        const counterByReason = {
+            readOnly: 'byReadOnly',
+            deniedRegex: 'byDeniedRegex',
+            scopes: 'byScopes',
+            tier: 'byTier',
+            actionDenial: 'byActionDenial',
+        };
         for (const registry of this.registries.values()) {
             for (const [toolName, tool] of registry) {
-                if (this.toolLookupCache.has(toolName)) {
+                if (contextTools && !contextTools.has(toolName))
                     continue;
+                const reason = this.getToolExclusionReason(toolName, tool, ctx);
+                if (!reason) {
+                    counts.available++;
                 }
-                if (config_1.GITLAB_READ_ONLY_MODE && !this.getReadOnlyTools().includes(toolName)) {
-                    filteredByReadOnly++;
-                    continue;
-                }
-                if (config_1.GITLAB_DENIED_TOOLS_REGEX?.test(toolName)) {
-                    filteredByDeniedRegex++;
-                    continue;
-                }
-                if (tokenScopes && !(0, TokenScopeDetector_1.isToolAvailableForScopes)(toolName, tokenScopes)) {
-                    filteredByScopes++;
-                    continue;
-                }
-                if (!ToolAvailability_1.ToolAvailability.isToolAvailable(toolName)) {
-                    filteredByTier++;
-                    continue;
+                else {
+                    const key = counterByReason[reason];
+                    if (key)
+                        counts[key]++;
                 }
-                const allActions = (0, schema_utils_1.extractActionsFromSchema)(tool.inputSchema);
-                if (allActions.length > 0 && (0, schema_utils_1.shouldRemoveTool)(toolName, allActions)) {
-                    filteredByActionDenial++;
+            }
+        }
+        return counts;
+    }
+    getFilterStats(instanceUrl) {
+        const url = this.resolveCacheUrl(instanceUrl);
+        const unreachableMode = this.isUnreachableFor(instanceUrl);
+        const contextTools = unreachableMode ? this.registries.get('context') : null;
+        let totalTools = 0;
+        for (const registry of this.registries.values()) {
+            for (const [toolName] of registry) {
+                if (contextTools && !contextTools.has(toolName))
                     continue;
-                }
-                filteredByTier++;
+                totalTools++;
             }
         }
+        const ctx = this.loadInstanceContext(url);
+        const { available: availableTools, byReadOnly: filteredByReadOnly, byDeniedRegex: filteredByDeniedRegex, byScopes: filteredByScopes, byTier: filteredByTier, byActionDenial: filteredByActionDenial, } = this.aggregateFilterCounters(ctx, contextTools);
         return {
             available: availableTools,
             total: totalTools,