Enable customizing model base type to non-generated external types

packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator/src/Providers/ModelProvider.cs

@@ -118,7 +118,51 @@ private IReadOnlyList<ModelProvider> BuildDerivedModels()
 
             return [.. derivedModels];
         }
-        internal override TypeProvider? BaseTypeProvider => BaseModelProvider;
+        internal override TypeProvider? BaseTypeProvider => _baseTypeProvider ??= BuildBaseTypeProvider();
+        private TypeProvider? _baseTypeProvider;
+
+        private TypeProvider? BuildBaseTypeProvider()
+        {
+            // First check if there's a generated base model
+            if (BaseModelProvider != null)
+            {
+                return BaseModelProvider;
+            }
+
+            // If there's a custom base type that's not a generated model, create a provider for it
+            if (CustomCodeView?.BaseType != null && !string.IsNullOrEmpty(CustomCodeView.BaseType.Namespace))
+            {
+                var baseType = CustomCodeView.BaseType;
+
+                // Try to find it in the CSharpTypeMap first
+                if (CodeModelGenerator.Instance.TypeFactory.CSharpTypeMap.TryGetValue(baseType, out var existingProvider))
+                {
+                    return existingProvider;
+                }
+
+                // If not found, try to look it up from Roslyn's customization compilation
+                var customization = CodeModelGenerator.Instance.SourceInputModel.Customization;
+                if (customization != null)
+                {
+                    // Construct the fully qualified metadata name in .NET format
+                    // For generic types, this uses backtick notation (e.g., "System.Collections.Generic.List`1")
+                    var fullyQualifiedName = baseType.IsGenericType
+                        ? $"{baseType.Namespace}.{baseType.Name}`{baseType.Arguments.Count}"
+                        : $"{baseType.Namespace}.{baseType.Name}";
+
+                    var baseTypeSymbol = customization.GetTypeByMetadataName(fullyQualifiedName);
+                    if (baseTypeSymbol != null)
+                    {
+                        var baseTypeProvider = new NamedTypeSymbolProvider(baseTypeSymbol, customization);
+                        // Cache it in CSharpTypeMap for future lookups
+                        CodeModelGenerator.Instance.TypeFactory.CSharpTypeMap[baseType] = baseTypeProvider;
+                        return baseTypeProvider;
+                    }
+                }
+            }
+
+            return null;
+        }
 
         public ModelProvider? BaseModelProvider
             => _baseModelProvider ??= BuildBaseModelProvider();
@@ -241,7 +285,7 @@ private static bool IsDiscriminator(InputProperty property)
 
         private ModelProvider? BuildBaseModelProvider()
         {
-            // consider models that have been customized to inherit from a different model
+            // consider models that have been customized to inherit from a different generated model
             if (CustomCodeView?.BaseType != null)
             {
                 var baseType = CustomCodeView.BaseType;
@@ -256,13 +300,22 @@ private static bool IsDiscriminator(InputProperty property)
                         baseType = CodeModelGenerator.Instance.TypeFactory.CreateCSharpType(baseInputModel);
                     }
                 }
+
+                // Try to find the base type in the CSharpTypeMap
                 if (baseType != null && CodeModelGenerator.Instance.TypeFactory.CSharpTypeMap.TryGetValue(
                         baseType,
                         out var customBaseType) &&
                     customBaseType is ModelProvider customBaseModel)
                 {
                     return customBaseModel;
                 }
+
+                // If the custom base type has a namespace (external type), we don't return it here
+                // as it's handled by BuildBaseTypeProvider() which returns a TypeProvider
+                if (!string.IsNullOrEmpty(baseType?.Namespace))
+                {
+                    return null;
+                }
             }
 
             if (_inputModel.BaseModel == null)

packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator/test/Providers/ModelProviders/ModelCustomizationTests.cs

@@ -1507,6 +1507,41 @@ private class TestNamespaceVisitor : NameSpaceVisitor
             }
         }
 
+        [Test]
+        public async Task CanCustomizeBaseModelToExternalType()
+        {
+            // This test verifies that a model can be customized to inherit from an external base type
+            // that is not generated during the current generation run (e.g., from another assembly)
+            var childModel = InputFactory.Model(
+                "mockInputModel",
+                properties: [InputFactory.Property("childProp", InputPrimitiveType.String)],
+                usage: InputModelTypeUsage.Json);
+
+            var mockGenerator = await MockHelpers.LoadMockGeneratorAsync(
+                inputModelTypes: [childModel],
+                compilation: async () => await Helpers.GetCompilationFromDirectoryAsync());
+
+            var modelProvider = mockGenerator.Object.OutputLibrary.TypeProviders.Single(t => t.Name == "MockInputModel") as ModelProvider;
+
+            // Should have customized base type from external assembly
+            Assert.IsNotNull(modelProvider);
+            Assert.IsNotNull(modelProvider!.BaseType);
+            Assert.IsNotNull(modelProvider.BaseTypeProvider);
+            Assert.AreEqual("ExternalBaseModel", modelProvider.BaseType!.Name);
+            Assert.AreEqual("Sample.Models", modelProvider.BaseType!.Namespace);
+
+            // The BaseModelProvider should be null since the base is not a generated model
+            Assert.IsNull(modelProvider.BaseModelProvider);
+
+            // But BaseTypeProvider should have the properties of the external base type
+            // ExternalBaseModel has 2 properties: ExternalProperty and ExternalDictionary
+            Assert.AreEqual(2, modelProvider.BaseTypeProvider!.Properties.Count, 
+                "ExternalBaseModel should have ExternalProperty and ExternalDictionary");
+            var externalPropertyNames = modelProvider.BaseTypeProvider.Properties.Select(p => p.Name).ToList();
+            Assert.Contains("ExternalProperty", externalPropertyNames);
+            Assert.Contains("ExternalDictionary", externalPropertyNames);
+        }
+
         private class TestNameVisitor : NameVisitor
         {
             public TypeProvider? InvokeVisit(TypeProvider type)

packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator/test/Providers/ModelProviders/TestData/ModelCustomizationTests/CanCustomizeBaseModelToExternalType/MockInputModel.cs

@@ -0,0 +1,19 @@
+#nullable disable
+
+using Sample.Models;
+using System.Collections.Generic;
+
+namespace Sample.Models
+{
+    public partial class MockInputModel : ExternalBaseModel
+    {
+    }
+
+    // This simulates an external base type from another assembly/namespace
+    // that is not generated by the current generation run
+    public class ExternalBaseModel
+    {
+        public string ExternalProperty { get; set; }
+        public IDictionary<string, string> ExternalDictionary { get; set; }
+    }
+}