[MCP] Fix for inconsistent MCP enabled check (#3303)

## Why make this change?
- Closes #3284

MCP endpoint returns 404 when the mcp config block is omitted, despite
mcp.enabled defaulting to true across schema, CLI, and model layers.

## What is this change?

`McpEndpointRouteBuilderExtensions.TryGetMcpOptions`: Falls back to new
`McpRuntimeOptions()` when `Runtime.Mcp` is `null`, so the `/mcp`
endpoint is registered by default.
`RestService.GetRouteAfterPathBase`: Guards the
`GlobalMcpEndpointDisabled` exception with an `IsMcpEnabled` check so
MCP path requests are not unconditionally rejected.

## How was this tested?
- [ ] Integration Tests
- [x] Unit Tests

## Sample Request(s)

/mcp
/health

Author: souvikghosh04

src/Azure.DataApiBuilder.Mcp/Core/McpEndpointRouteBuilderExtensions.cs

@@ -22,7 +22,14 @@ public static IEndpointRouteBuilder MapDabMcp(
             RuntimeConfigProvider runtimeConfigProvider,
             [StringSyntax("Route")] string pattern = "")
         {
-            if (!TryGetMcpOptions(runtimeConfigProvider, out McpRuntimeOptions? mcpOptions) || mcpOptions == null || !mcpOptions.Enabled)
+            if (!runtimeConfigProvider.TryGetConfig(out RuntimeConfig? runtimeConfig))
+            {
+                return endpoints;
+            }
+
+            McpRuntimeOptions mcpOptions = runtimeConfig?.Runtime?.Mcp ?? new McpRuntimeOptions();
+
+            if (!mcpOptions.Enabled)
             {
                 return endpoints;
             }
@@ -34,24 +41,5 @@ public static IEndpointRouteBuilder MapDabMcp(
 
             return endpoints;
         }
-
-        /// <summary>
-        /// Gets MCP options from the runtime configuration
-        /// </summary>
-        /// <param name="runtimeConfigProvider">Runtime config provider</param>
-        /// <param name="mcpOptions">MCP options</param>
-        /// <returns>True if MCP options were found, false otherwise</returns>
-        private static bool TryGetMcpOptions(RuntimeConfigProvider runtimeConfigProvider, out McpRuntimeOptions? mcpOptions)
-        {
-            mcpOptions = null;
-
-            if (!runtimeConfigProvider.TryGetConfig(out RuntimeConfig? runtimeConfig))
-            {
-                return false;
-            }
-
-            mcpOptions = runtimeConfig?.Runtime?.Mcp;
-            return mcpOptions != null;
-        }
     }
 }

src/Cli/ConfigGenerator.cs

@@ -2653,7 +2653,7 @@ public static bool IsConfigValid(ValidateOptions options, FileSystemRuntimeConfi
             {
                 if (runtimeConfigProvider.TryGetConfig(out RuntimeConfig? config) && config is not null)
                 {
-                    bool mcpEnabled = config.Runtime?.Mcp?.Enabled == true;
+                    bool mcpEnabled = config.IsMcpEnabled;
                     if (mcpEnabled)
                     {
                         foreach (KeyValuePair<string, Entity> entity in config.Entities)

src/Core/Services/RestService.cs

@@ -402,15 +402,17 @@ private bool TryGetStoredProcedureRESTVerbs(string entityName, [NotNullWhen(true
         /// does not match the configured REST path or the global REST endpoint is disabled.</exception>
         public string GetRouteAfterPathBase(string route)
         {
-            string configuredRestPathBase = _runtimeConfigProvider.GetConfig().RestPath;
+            RuntimeConfig runtimeConfig = _runtimeConfigProvider.GetConfig();
+            string configuredRestPathBase = runtimeConfig.RestPath;
 
             // Strip the leading '/' from the REST path provided in the runtime configuration
             // because the input argument 'route' has no starting '/'.
             // The RuntimeConfigProvider enforces the expectation that the configured REST path starts with a
             // forward slash '/'.
             configuredRestPathBase = configuredRestPathBase.Substring(1);
 
-            if (route.Equals(_runtimeConfigProvider.GetConfig().McpPath.Substring(1)))
+            if (route.Equals(runtimeConfig.McpPath.Substring(1))
+                && !runtimeConfig.IsMcpEnabled)
             {
                 throw new DataApiBuilderException(
                     message: $"Route {route} was not found.",

src/Service.Tests/Configuration/McpRuntimeOptionsSerializationTests.cs

@@ -191,6 +191,94 @@ public void TestBackwardCompatibilityDeserializationWithoutDescriptionField()
             Assert.IsNull(deserializedConfig.Runtime.Mcp.Description, "Description should be null when not present in JSON");
         }
 
+        /// <summary>
+        /// When the mcp and runtime config blocks are omitted entirely, IsMcpEnabled should default to true.
+        /// </summary>
+        [TestMethod]
+        public void TestIsMcpEnabledDefaultsTrueWhenMcpAndRuntimeBlocksAbsent()
+        {
+            // Arrange - config with no runtime/mcp block
+            string configJson = @"{
+                ""$schema"": ""test-schema"",
+                ""data-source"": {
+                    ""database-type"": ""mssql"",
+                    ""connection-string"": ""Server=test;Database=test;""
+                },
+                ""entities"": {}
+            }";
+
+            // Act
+            bool parseSuccess = RuntimeConfigLoader.TryParseConfig(configJson, out RuntimeConfig config);
+
+            // Assert
+            Assert.IsTrue(parseSuccess);
+            Assert.IsNull(config.Runtime, "Runtime should be null when not specified");
+            Assert.IsNull(config.Runtime?.Mcp, "Mcp should be null when not specified");
+            Assert.IsTrue(config.IsMcpEnabled, "IsMcpEnabled should default to true when mcp block is absent");
+            Assert.AreEqual(McpRuntimeOptions.DEFAULT_PATH, config.McpPath, "McpPath should return default when mcp block is absent");
+        }
+
+        /// <summary>
+        /// When the mcp config block is present but enabled is not specified,
+        /// IsMcpEnabled should default to true.
+        /// </summary>
+        [TestMethod]
+        public void TestIsMcpEnabledDefaultsTrueWhenEnabledNotSpecified()
+        {
+            // Arrange - config with mcp block but no enabled field
+            string configJson = @"{
+                ""$schema"": ""test-schema"",
+                ""data-source"": {
+                    ""database-type"": ""mssql"",
+                    ""connection-string"": ""Server=test;Database=test;""
+                },
+                ""runtime"": {
+                    ""mcp"": {
+                        ""path"": ""/mcp""
+                    }
+                },
+                ""entities"": {}
+            }";
+
+            // Act
+            bool parseSuccess = RuntimeConfigLoader.TryParseConfig(configJson, out RuntimeConfig config);
+
+            // Assert
+            Assert.IsTrue(parseSuccess);
+            Assert.IsNotNull(config.Runtime?.Mcp);
+            Assert.IsTrue(config.IsMcpEnabled, "IsMcpEnabled should default to true when enabled is not specified");
+        }
+
+        /// <summary>
+        /// When mcp.enabled is explicitly set to false, IsMcpEnabled should return false.
+        /// </summary>
+        [TestMethod]
+        public void TestIsMcpEnabledReturnsFalseWhenExplicitlyDisabled()
+        {
+            // Arrange
+            string configJson = @"{
+                ""$schema"": ""test-schema"",
+                ""data-source"": {
+                    ""database-type"": ""mssql"",
+                    ""connection-string"": ""Server=test;Database=test;""
+                },
+                ""runtime"": {
+                    ""mcp"": {
+                        ""enabled"": false
+                    }
+                },
+                ""entities"": {}
+            }";
+
+            // Act
+            bool parseSuccess = RuntimeConfigLoader.TryParseConfig(configJson, out RuntimeConfig config);
+
+            // Assert
+            Assert.IsTrue(parseSuccess);
+            Assert.IsNotNull(config.Runtime?.Mcp);
+            Assert.IsFalse(config.IsMcpEnabled, "IsMcpEnabled should be false when explicitly disabled");
+        }
+
         /// <summary>
         /// Creates a minimal RuntimeConfig with the specified MCP options for testing.
         /// </summary>

src/Service.Tests/UnitTests/RestServiceUnitTests.cs

@@ -167,6 +167,46 @@ public void SinglePathMatchingTest()
 
         #endregion
 
+        #region MCP Path Guard Tests
+
+        /// <summary>
+        /// When MCP is explicitly disabled and the route matches the MCP path (default or custom),
+        /// GetRouteAfterPathBase should throw GlobalMcpEndpointDisabled.
+        /// </summary>
+        [DataTestMethod]
+        [DataRow("/mcp", "mcp", DisplayName = "MCP disabled with default path")]
+        [DataRow("/custom-mcp", "custom-mcp", DisplayName = "MCP disabled with custom path")]
+        public void McpPathThrowsWhenMcpDisabled(string mcpPath, string route)
+        {
+            InitializeTestWithMcpConfig("/api", new McpRuntimeOptions(Enabled: false, Path: mcpPath));
+            DataApiBuilderException ex = Assert.ThrowsException<DataApiBuilderException>(
+                () => _restService.GetRouteAfterPathBase(route));
+            Assert.AreEqual(HttpStatusCode.NotFound, ex.StatusCode);
+            Assert.AreEqual(DataApiBuilderException.SubStatusCodes.GlobalMcpEndpointDisabled, ex.SubStatusCode);
+        }
+
+        /// <summary>
+        /// When MCP is enabled (explicitly or by default when config is absent),
+        /// the MCP path route should NOT throw GlobalMcpEndpointDisabled.
+        /// It falls through to the normal path-base check.
+        /// </summary>
+        [DataTestMethod]
+        [DataRow(true, DisplayName = "MCP explicitly enabled")]
+        [DataRow(null, DisplayName = "MCP config absent (defaults to enabled)")]
+        public void McpPathDoesNotThrowGlobalMcpEndpointDisabledWhenMcpEnabled(bool? mcpEnabled)
+        {
+            McpRuntimeOptions mcpOptions = mcpEnabled.HasValue ? new McpRuntimeOptions(Enabled: mcpEnabled.Value) : null;
+            InitializeTestWithMcpConfig("/api", mcpOptions);
+            // "mcp" doesn't start with "api", so it should throw BadRequest (invalid path),
+            // NOT GlobalMcpEndpointDisabled.
+            DataApiBuilderException ex = Assert.ThrowsException<DataApiBuilderException>(
+                () => _restService.GetRouteAfterPathBase("mcp"));
+            Assert.AreEqual(HttpStatusCode.BadRequest, ex.StatusCode);
+            Assert.AreEqual(DataApiBuilderException.SubStatusCodes.BadRequest, ex.SubStatusCode);
+        }
+
+        #endregion
+
         #region Helper Functions
 
         /// <summary>
@@ -215,15 +255,15 @@ public static void InitializeTestWithMultipleEntityPaths(string restRoutePrefix,
         /// <summary>
         /// Core helper to initialize REST Service with specified entity path mappings.
         /// </summary>
-        private static void InitializeTestWithEntityPaths(string restRoutePrefix, Dictionary<string, string> entityPaths)
+        private static void InitializeTestWithEntityPaths(string restRoutePrefix, Dictionary<string, string> entityPaths, McpRuntimeOptions mcpOptions = null, bool useMcpParam = false)
         {
             RuntimeConfig mockConfig = new(
                Schema: "",
                DataSource: new(DatabaseType.PostgreSQL, "", new()),
                Runtime: new(
                    Rest: new(Path: restRoutePrefix),
                    GraphQL: new(),
-                   Mcp: new(),
+                   Mcp: useMcpParam ? mcpOptions : (mcpOptions ?? new()),
                    Host: new(null, null)
                ),
                Entities: new(new Dictionary<string, Entity>())
@@ -306,6 +346,16 @@ private static void InitializeTestWithEntityPaths(string restRoutePrefix, Dictio
                 provider,
                 requestValidator);
         }
+
+        /// <summary>
+        /// Initializes RestService with a specific MCP configuration for testing MCP path guard behavior.
+        /// </summary>
+        /// <param name="restRoutePrefix">REST path prefix (e.g., "/api").</param>
+        /// <param name="mcpOptions">MCP options, or null to simulate absent mcp config block.</param>
+        private static void InitializeTestWithMcpConfig(string restRoutePrefix, McpRuntimeOptions mcpOptions)
+        {
+            InitializeTestWithEntityPaths(restRoutePrefix, new Dictionary<string, string>(), mcpOptions, useMcpParam: true);
+        }
         #endregion
     }
 }