.NET: Prefer HTTPS Aspire DevUI backends

dotnet/samples/05-end-to-end/DevUIAspireIntegration/DevUIIntegration.AppHost/Program.cs

@@ -12,8 +12,8 @@
 foundry.AsExisting(existingFoundryName, existingFoundryResourceGroup);
 
 // Add the writer agent service
-var writerAgent = builder.AddProject<Projects.WriterAgent>("writer-agent")
-    .WithHttpHealthCheck("/health")
+var writerAgent = builder.AddProject<Projects.WriterAgent>("writer-agent", launchProfileName: "https")
+    .WithHttpHealthCheck("/health", endpointName: "https")
     .WithReference(foundry).WaitFor(foundry);
 
 // Add the editor agent service

dotnet/samples/05-end-to-end/DevUIAspireIntegration/README.md

@@ -7,6 +7,8 @@ The solution contains two agent services:
 - **WriterAgent** — a simple agent that writes short stories (≤ 300 words) about a given topic.
 - **EditorAgent** — an agent that edits stories for grammar and style, selects a title, and formats the result for publishing. It also demonstrates tool use via `AIFunctionFactory`.
 
+The WriterAgent is configured with HTTPS redirection so the Aspire DevUI integration can be tested against an agent service that exposes both HTTP and HTTPS endpoints.
+
 ## Prerequisites
 
 - [.NET 10 SDK](https://dotnet.microsoft.com/en-us/download/dotnet/10.0)

dotnet/samples/05-end-to-end/DevUIAspireIntegration/WriterAgent/Program.cs

@@ -26,6 +26,8 @@
 
 var app = builder.Build();
 
+app.UseHttpsRedirection();
+
 // Map OpenAI API endpoints — DevUI aggregator routes requests here
 app.MapOpenAIResponses();
 app.MapOpenAIConversations();

dotnet/samples/05-end-to-end/DevUIAspireIntegration/WriterAgent/Properties/launchSettings.json

@@ -1,6 +1,15 @@
 {
   "$schema": "http://json.schemastore.org/launchsettings.json",
   "profiles": {
+    "https": {
+      "commandName": "Project",
+      "dotnetRunMessages": true,
+      "launchBrowser": true,
+      "applicationUrl": "https://localhost:7280;http://localhost:5280",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      }
+    },
     "http": {
       "commandName": "Project",
       "dotnetRunMessages": true,

dotnet/src/Aspire.Hosting.AgentFramework.DevUI/DevUIAggregatorHostedService.cs

@@ -30,6 +30,7 @@ namespace Aspire.Hosting.AgentFramework;
 internal sealed class DevUIAggregatorHostedService : IAsyncDisposable
 {
     private static readonly FileExtensionContentTypeProvider s_contentTypeProvider = new();
+    private static readonly string[] s_preferredBackendEndpointNames = ["https", "http"];
 
     private WebApplication? _app;
     private readonly DevUIResource _resource;
@@ -283,7 +284,7 @@ private void MapRoutes(WebApplication app)
     /// Resolves backend URLs from the resource's <see cref="AgentServiceAnnotation"/> annotations.
     /// This method does not cache results to ensure late-allocated backends are always discovered.
     /// </summary>
-    private Dictionary<string, string> ResolveBackends()
+    internal Dictionary<string, string> ResolveBackends()
     {
         var result = new Dictionary<string, string>(StringComparer.Ordinal);
 
@@ -296,21 +297,39 @@ private Dictionary<string, string> ResolveBackends()
 
             var prefix = annotation.EntityIdPrefix ?? annotation.AgentService.Name;
 
+            var endpointUrl = this.ResolveBackendUrl(rwe, prefix);
+            if (endpointUrl is not null)
+            {
+                result[prefix] = endpointUrl;
+            }
+        }
+
+        return result;
+    }
+
+    private string? ResolveBackendUrl(IResourceWithEndpoints resource, string prefix)
+    {
+        foreach (var endpointName in s_preferredBackendEndpointNames)
+        {
             try
             {
-                var endpoint = rwe.GetEndpoint("http");
+                var endpoint = resource.GetEndpoint(endpointName);
                 if (endpoint.IsAllocated)
                 {
-                    result[prefix] = endpoint.Url;
+                    return endpoint.Url;
                 }
             }
-            catch (Exception ex)
+            catch (InvalidOperationException ex)
             {
-                this._logger.LogDebug(ex, "Backend '{Prefix}' endpoint not yet available", prefix);
+                this._logger.LogDebug(
+                    ex,
+                    "Backend '{Prefix}' {EndpointName} endpoint not yet available",
+                    prefix,
+                    endpointName);
             }
         }
 
-        return result;
+        return null;
     }
 
     private async Task<IResult> AggregateEntitiesAsync(HttpContext context)

dotnet/tests/Aspire.Hosting.AgentFramework.DevUI.UnitTests/DevUIAggregatorHostedServiceTests.cs

@@ -1,8 +1,10 @@
 // Copyright (c) Microsoft. All rights reserved.
 
 using System.Linq;
+using System.Net.Sockets;
 using Aspire.Hosting.ApplicationModel;
 using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.Logging.Abstractions;
 
 namespace Aspire.Hosting.AgentFramework.DevUI.UnitTests;
 
@@ -245,6 +247,72 @@ public void WithAgentService_MultipleServices_CreatesMultipleAnnotations()
 
     #endregion
 
+    #region Backend Endpoint Selection Tests
+
+    /// <summary>
+    /// Verifies that ResolveBackends prefers the HTTPS endpoint when both HTTP and HTTPS are allocated.
+    /// </summary>
+    [Fact]
+    public void ResolveBackends_WithHttpAndHttpsEndpoints_PrefersHttps()
+    {
+        // Arrange
+        var devui = new DevUIResource("devui");
+        var agentService = new TestEndpointResource("writer-agent");
+        AddAllocatedEndpoint(agentService, "http", "http", 5050);
+        AddAllocatedEndpoint(agentService, "https", "https", 7443);
+        devui.Annotations.Add(new AgentServiceAnnotation(agentService));
+        var aggregator = new DevUIAggregatorHostedService(devui, NullLogger.Instance);
+
+        // Act
+        var backends = aggregator.ResolveBackends();
+
+        // Assert
+        Assert.Equal("https://localhost:7443", backends["writer-agent"]);
+    }
+
+    /// <summary>
+    /// Verifies that ResolveBackends falls back to HTTP when the HTTPS endpoint is not present.
+    /// </summary>
+    [Fact]
+    public void ResolveBackends_WithOnlyHttpEndpoint_UsesHttp()
+    {
+        // Arrange
+        var devui = new DevUIResource("devui");
+        var agentService = new TestEndpointResource("writer-agent");
+        AddAllocatedEndpoint(agentService, "http", "http", 5050);
+        devui.Annotations.Add(new AgentServiceAnnotation(agentService));
+        var aggregator = new DevUIAggregatorHostedService(devui, NullLogger.Instance);
+
+        // Act
+        var backends = aggregator.ResolveBackends();
+
+        // Assert
+        Assert.Equal("http://localhost:5050", backends["writer-agent"]);
+    }
+
+    /// <summary>
+    /// Verifies that ResolveBackends falls back to HTTP when the HTTPS endpoint has not been allocated yet.
+    /// </summary>
+    [Fact]
+    public void ResolveBackends_WithUnallocatedHttpsEndpoint_UsesHttp()
+    {
+        // Arrange
+        var devui = new DevUIResource("devui");
+        var agentService = new TestEndpointResource("writer-agent");
+        AddEndpoint(agentService, "https", "https");
+        AddAllocatedEndpoint(agentService, "http", "http", 5050);
+        devui.Annotations.Add(new AgentServiceAnnotation(agentService));
+        var aggregator = new DevUIAggregatorHostedService(devui, NullLogger.Instance);
+
+        // Act
+        var backends = aggregator.ResolveBackends();
+
+        // Assert
+        Assert.Equal("http://localhost:5050", backends["writer-agent"]);
+    }
+
+    #endregion
+
     #region Entity ID Parsing Tests
 
     /// <summary>
@@ -294,5 +362,33 @@ private static IResourceBuilder<IResourceWithEndpoints> CreateMockAgentServiceBu
         return mockBuilder.Object;
     }
 
+    private static void AddAllocatedEndpoint(
+        TestEndpointResource resource,
+        string name,
+        string uriScheme,
+        int port)
+    {
+        var endpoint = AddEndpoint(resource, name, uriScheme);
+        endpoint.AllocatedEndpoint = new AllocatedEndpoint(endpoint, "localhost", port);
+    }
+
+    private static EndpointAnnotation AddEndpoint(
+        TestEndpointResource resource,
+        string name,
+        string uriScheme)
+    {
+        var endpoint = new EndpointAnnotation(
+            ProtocolType.Tcp,
+            uriScheme: uriScheme,
+            name: name,
+            port: null,
+            isProxied: false);
+
+        resource.Annotations.Add(endpoint);
+        return endpoint;
+    }
+
+    private sealed class TestEndpointResource(string name) : Resource(name), IResourceWithEndpoints;
+
     #endregion
 }