Avoid starting web host in MCP stdio mode (#3676)

## Summary

`dab start --mcp-stdio` communicates over stdin/stdout, but the stdio
helper was calling `host.Start()`. That starts the web host and Kestrel,
so stdio mode still tried to bind the configured HTTP port. When the
port was occupied, the process exited before the MCP `initialize`
handshake.

The stdio path already initializes and registers MCP tools directly from
DI, so it can run the stdio JSON-RPC loop without starting Kestrel.

Fixes #3675.

## Changes

- Avoid starting the ASP.NET Core host when running the engine in MCP
stdio mode.
- Keep MCP tool registry initialization in the stdio path before running
the JSON-RPC loop.
- Dispose the host after the stdio loop exits without calling
`StartAsync()` or `StopAsync()`.
- Add a regression test that proves `RunMcpStdioHost()` does not call
`IHost.StartAsync()`/`StopAsync()`, still starts the stdio server loop,
and disposes the host.

## Verification

```bash
dotnet test src/Service.Tests/Azure.DataApiBuilder.Service.Tests.csproj --filter 'FullyQualifiedName~McpStdioHelperTests' -p:RuntimeIdentifiers= -p:UseAppHost=false
dotnet test src/Service.Tests/Azure.DataApiBuilder.Service.Tests.csproj --filter 'FullyQualifiedName~McpStdioHelperTests|FullyQualifiedName~McpStdioServerRunAsyncTests|FullyQualifiedName~McpStdioServerInitializeTests|FullyQualifiedName~McpStdioServerContentBlockTests|FullyQualifiedName~McpToolRegistryTests' -p:RuntimeIdentifiers= -p:UseAppHost=false
git diff --check
```

A runtime smoke also occupied `127.0.0.1:5155`, pointed
`ASPNETCORE_URLS` at that occupied port, and verified that the service
completed MCP `initialize` and `shutdown` over stdio without an
address-in-use error.

Co-authored-by: RubenCerna2079 <32799214+RubenCerna2079@users.noreply.github.com>

Author: jstar0

src/Service.Tests/UnitTests/McpStdioHelperTests.cs

@@ -0,0 +1,111 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#nullable enable
+
+using System.Threading;
+using System.Threading.Tasks;
+using Azure.DataApiBuilder.Mcp.Core;
+using Azure.DataApiBuilder.Service.Utilities;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Azure.DataApiBuilder.Service.Tests.UnitTests
+{
+    [TestClass]
+    public class McpStdioHelperTests
+    {
+        [TestMethod]
+        public void RunMcpStdioHost_DoesNotStartWebHost()
+        {
+            ServiceCollection services = new();
+            TestApplicationLifetime lifetime = new();
+            TestMcpStdioServer stdioServer = new();
+
+            services.AddSingleton<McpToolRegistry>();
+            services.AddSingleton<IHostApplicationLifetime>(lifetime);
+            services.AddSingleton<IMcpStdioServer>(stdioServer);
+
+            using ServiceProvider serviceProvider = services.BuildServiceProvider();
+            TestHost host = new(serviceProvider);
+
+            bool result = McpStdioHelper.RunMcpStdioHost(host);
+
+            Assert.IsTrue(result);
+            Assert.AreEqual(0, host.StartAsyncCallCount,
+                "MCP stdio mode should not start the ASP.NET Core web host because that binds HTTP ports.");
+            Assert.AreEqual(0, host.StopAsyncCallCount,
+                "MCP stdio mode should not stop a host that was never started.");
+            Assert.AreEqual(1, stdioServer.RunAsyncCallCount,
+                "MCP stdio mode should still run the stdio JSON-RPC loop.");
+            Assert.AreEqual(lifetime.ApplicationStopping, stdioServer.CancellationToken,
+                "The stdio loop should keep using the host lifetime cancellation token.");
+            Assert.AreEqual(1, host.DisposeCallCount,
+                "MCP stdio mode should dispose the host after the stdio loop exits.");
+        }
+
+        private sealed class TestHost : IHost
+        {
+            public TestHost(System.IServiceProvider services)
+            {
+                Services = services;
+            }
+
+            public System.IServiceProvider Services { get; }
+
+            public int StartAsyncCallCount { get; private set; }
+
+            public int StopAsyncCallCount { get; private set; }
+
+            public int DisposeCallCount { get; private set; }
+
+            public Task StartAsync(CancellationToken cancellationToken = default)
+            {
+                StartAsyncCallCount++;
+                return Task.CompletedTask;
+            }
+
+            public Task StopAsync(CancellationToken cancellationToken = default)
+            {
+                StopAsyncCallCount++;
+                return Task.CompletedTask;
+            }
+
+            public void Dispose()
+            {
+                DisposeCallCount++;
+            }
+        }
+
+        private sealed class TestApplicationLifetime : IHostApplicationLifetime
+        {
+            private readonly CancellationTokenSource _applicationStopping = new();
+
+            public CancellationToken ApplicationStarted => CancellationToken.None;
+
+            public CancellationToken ApplicationStopping => _applicationStopping.Token;
+
+            public CancellationToken ApplicationStopped => CancellationToken.None;
+
+            public void StopApplication()
+            {
+                _applicationStopping.Cancel();
+            }
+        }
+
+        private sealed class TestMcpStdioServer : IMcpStdioServer
+        {
+            public int RunAsyncCallCount { get; private set; }
+
+            public CancellationToken CancellationToken { get; private set; }
+
+            public Task RunAsync(CancellationToken cancellationToken)
+            {
+                RunAsyncCallCount++;
+                CancellationToken = cancellationToken;
+                return Task.CompletedTask;
+            }
+        }
+    }
+}

src/Service/Utilities/McpStdioHelper.cs

@@ -76,24 +76,28 @@ public static void ConfigureMcpStdio(IConfigurationBuilder builder, string? mcpR
         /// <param name="host"> The host to run.</param>
         public static bool RunMcpStdioHost(IHost host)
         {
-            host.Start();
-
-            Mcp.Core.McpToolRegistry registry =
-                host.Services.GetRequiredService<Mcp.Core.McpToolRegistry>();
-            IEnumerable<Mcp.Model.IMcpTool> tools =
-                host.Services.GetServices<Mcp.Model.IMcpTool>();
+            try
+            {
+                Mcp.Core.McpToolRegistry registry =
+                    host.Services.GetRequiredService<Mcp.Core.McpToolRegistry>();
+                IEnumerable<Mcp.Model.IMcpTool> tools =
+                    host.Services.GetServices<Mcp.Model.IMcpTool>();
 
-            Mcp.Core.McpToolRegistry.InitializeAndRegisterTools(tools, registry, host.Services);
+                Mcp.Core.McpToolRegistry.InitializeAndRegisterTools(tools, registry, host.Services);
 
-            IHostApplicationLifetime lifetime =
-                host.Services.GetRequiredService<IHostApplicationLifetime>();
-            Mcp.Core.IMcpStdioServer stdio =
-                host.Services.GetRequiredService<Mcp.Core.IMcpStdioServer>();
+                IHostApplicationLifetime lifetime =
+                    host.Services.GetRequiredService<IHostApplicationLifetime>();
+                Mcp.Core.IMcpStdioServer stdio =
+                    host.Services.GetRequiredService<Mcp.Core.IMcpStdioServer>();
 
-            stdio.RunAsync(lifetime.ApplicationStopping).GetAwaiter().GetResult();
-            host.StopAsync().GetAwaiter().GetResult();
+                stdio.RunAsync(lifetime.ApplicationStopping).GetAwaiter().GetResult();
 
-            return true;
+                return true;
+            }
+            finally
+            {
+                host.Dispose();
+            }
         }
     }
 }