Centralize Foundry project reference wiring to address review feedback

Replace the bespoke AddProjectReference helper (which re-implemented the
IResourceWithWaitSupport cast + WaitFor) with a shared internal
WithProjectReference helper in ProjectBuilderExtension.cs. The public
WithReference(project) overload now delegates to it, so the cast lives in
exactly one place. AsHostedAgent calls the shared helper with an encoded
connection name in both run and publish mode, preserving deploy-safe env var
names and run/publish symmetry while keeping run-mode WaitFor.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: maddymontaquila

src/Aspire.Hosting.Foundry/HostedAgent/HostedAgentBuilderExtension.cs

@@ -134,7 +134,8 @@ private static void AddProjectReferenceForRunMode<T>(
         where T : IResourceWithEndpoints, IResourceWithEnvironment, IComputeResource
     {
         // Run mode waits for the project to provision so the agent's connection variables resolve before it starts.
-        AddProjectReference(builder, project, waitForProject: true);
+        // Use the encoded connection name so run and publish emit identical variable names (see EncodeProjectConnectionName).
+        builder.WithProjectReference(project, connectionName: EncodeProjectConnectionName(project), waitFor: true);
 
         // The default ACR is required for publish-time image push, but in run mode it adds noise to the dashboard.
         // When a hosted agent references a Foundry project for local execution, remove the default registry resource.
@@ -145,36 +146,14 @@ private static void AddProjectReferenceForRunMode<T>(
         }
     }
 
-    // Injects the Foundry project reference into the compute resource so the agent can reach the project
-    // via the standard Aspire reference environment variables (ConnectionStrings__{name}, {NAME}_URI, ...).
-    //
-    // This must produce identical variable names in run and publish mode so an app that reads them locally
-    // keeps working once deployed. The connection-string variable is named "ConnectionStrings__{connectionName}".
-    // Foundry validates hosted agent environment variable names against ^[A-Za-z0-9_]+$ at deploy time (see
-    // HostedAgentConfiguration), so a project name containing '-' — including the auto-generated default
-    // "{resource.Name}-proj" — would otherwise emit "ConnectionStrings__{name}-proj" and fail deployment.
-    // Encode the connection name up front so both modes stay symmetric and deploy-safe; for already-valid names
-    // (e.g. "myproject") this is a no-op.
-    //
-    // We deliberately call the general WithReference overload (with an explicit connectionName) rather than the
-    // Foundry-specific WithReference(project) overload: the latter ignores connectionName and always emits the
-    // raw resource name. The Foundry overload also implicitly applies WaitFor(project); we reproduce that here
-    // for run mode via waitForProject, but skip it in publish mode where waiting has no meaning.
-    private static IResourceBuilder<T> AddProjectReference<T>(
-        IResourceBuilder<T> builder,
-        IResourceBuilder<AzureCognitiveServicesProjectResource> project,
-        bool waitForProject)
-        where T : IResourceWithEndpoints, IResourceWithEnvironment, IComputeResource
-    {
-        builder.WithReference(project, connectionName: EnvironmentVariableNameEncoder.Encode(project.Resource.Name));
-
-        if (waitForProject && builder is IResourceBuilder<IResourceWithWaitSupport> waitableBuilder)
-        {
-            waitableBuilder.WaitFor(project);
-        }
-
-        return builder;
-    }
+    // Encodes the project's connection name so the resulting reference environment variables stay deploy-safe.
+    // A project reference emits "ConnectionStrings__{connectionName}" (plus "{NAME}_URI", ...). Foundry validates
+    // hosted agent environment variable names against ^[A-Za-z0-9_]+$ at deploy time (see HostedAgentConfiguration),
+    // so a project name containing '-' — including the auto-generated default "{resource.Name}-proj" — would
+    // otherwise emit "ConnectionStrings__{name}-proj" and fail deployment. Encoding up front keeps run and publish
+    // mode symmetric and deploy-safe; for already-valid names (e.g. "myproject") this is a no-op.
+    private static string EncodeProjectConnectionName(IResourceBuilder<AzureCognitiveServicesProjectResource> project)
+        => EnvironmentVariableNameEncoder.Encode(project.Resource.Name);
 
     private static IResourceBuilder<AzureCognitiveServicesProjectResource> ResolveProjectBuilderForPublish<T>(IResourceBuilder<T> builder)
         where T : IResourceWithEndpoints, IResourceWithEnvironment, IComputeResource
@@ -375,7 +354,7 @@ private static void ConfigurePublishMode<T>(
         // needed during environment variable resolution in the deployment phase, and
         // mirrors the reference added in run mode so the variables match in both modes.
         // WaitFor is omitted in publish mode where it has no meaning.
-        AddProjectReference(builder, project, waitForProject: false);
+        builder.WithProjectReference(project, connectionName: EncodeProjectConnectionName(project), waitFor: false);
 
         builder.ApplicationBuilder.AddResource(hostedAgent)
             .WithIconName("Agents")

src/Aspire.Hosting.Foundry/Project/ProjectBuilderExtension.cs

@@ -69,13 +69,33 @@ public static IResourceBuilder<TDestination> WithReference<TDestination>(this IR
         ArgumentNullException.ThrowIfNull(builder);
         ArgumentNullException.ThrowIfNull(project);
 
+        return WithProjectReference(builder, project, connectionName: null, waitFor: true);
+    }
+
+    // Centralizes the wiring for referencing a Foundry project so callers never re-implement the standard
+    // reference plus the IResourceWithWaitSupport cast + WaitFor. The public WithReference overload above
+    // delegates here with the defaults (raw connection name, always wait).
+    //
+    // connectionName lets a caller override the default connection name. Hosted agents need this because
+    // Foundry validates every hosted-agent environment variable name against ^[A-Za-z0-9_]+$ at deploy time
+    // (see HostedAgentConfiguration), and a project name containing '-' would otherwise emit
+    // "ConnectionStrings__{name}-proj" and fail deployment. waitFor is skipped in publish mode where waiting
+    // has no meaning.
+    internal static IResourceBuilder<TDestination> WithProjectReference<TDestination>(
+        this IResourceBuilder<TDestination> builder,
+        IResourceBuilder<AzureCognitiveServicesProjectResource> project,
+        string? connectionName,
+        bool waitFor)
+        where TDestination : IResourceWithEnvironment
+    {
         // Add standard references and environment variables
-        ResourceBuilderExtensions.WithReference(builder, project);
+        ResourceBuilderExtensions.WithReference(builder, project, connectionName);
 
-        if (builder is IResourceBuilder<IResourceWithWaitSupport> waitableBuilder)
+        if (waitFor && builder is IResourceBuilder<IResourceWithWaitSupport> waitableBuilder)
         {
             waitableBuilder.WaitFor(project);
         }
+
         return builder;
     }