Increase namespace/type-name shortening threshold from 64 to 128

Reduce the aggressiveness of the recently-added namespace segment and
type name shortening by raising the default length threshold from 64 to
128 characters. Names between 65 and 128 characters now keep their full
names instead of being truncated with a hash suffix.

- StringExtensions.DefaultMaxNameSegmentLength: 64 -> 128
- CommonLanguageRefiner.ShortenOversizedNamespaceSegments default: 64 -> 128
- Updated affected tests and CHANGELOG

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

Author: ramsessanchez

CHANGELOG.md

@@ -13,6 +13,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Changed
 
+- Reduced the aggressiveness of namespace segment and type name shortening by raising the length threshold from 64 to 128 characters, so names between 65 and 128 characters keep their full names.
+
 ## [1.33.0] - 2026-07-06
 
 ### Added

src/Kiota.Builder/Extensions/StringExtensions.cs

@@ -75,14 +75,14 @@ public static string ShortenFileName(this string name, int length = 251) =>
         (!string.IsNullOrEmpty(name) && name.Length > length) ? HashString(name).ToLowerInvariant() : name;
 #pragma warning restore CA1308
 
-    private const int DefaultMaxNameSegmentLength = 64;
+    private const int DefaultMaxNameSegmentLength = 128;
     private const int HashSuffixLength = 8;
     /// <summary>
     /// Shortens a name segment to the specified maximum length by truncating and appending a short hash suffix.
     /// Preserves human readability by keeping the first part of the original name.
     /// </summary>
     /// <param name="name">The name to potentially shorten</param>
-    /// <param name="maxLength">The maximum allowed length. Default is 64.</param>
+    /// <param name="maxLength">The maximum allowed length. Default is 128.</param>
     /// <returns>The original name if within limits, or a truncated name with hash suffix for uniqueness</returns>
     public static string ShortenNameSegment(this string name, int maxLength = DefaultMaxNameSegmentLength)
     {

src/Kiota.Builder/Refiners/CommonLanguageRefiner.cs

@@ -1635,7 +1635,7 @@ protected static void DeduplicateErrorMappings(CodeElement codeElement)
     /// that map only namespaces to directories and group types into barrel files, where renaming types would
     /// break downstream name-based generation without any file-system benefit.
     /// </param>
-    protected static void ShortenOversizedNamespaceSegments(CodeElement currentElement, int maxSegmentLength = 64, bool shortenTypeNames = true)
+    protected static void ShortenOversizedNamespaceSegments(CodeElement currentElement, int maxSegmentLength = 128, bool shortenTypeNames = true)
     {
         if (currentElement is CodeNamespace codeNamespace && !string.IsNullOrEmpty(codeNamespace.Name))
         {

tests/Kiota.Builder.Tests/Extensions/StringExtensionsTests.cs

@@ -140,17 +140,17 @@ public void ShortenNameSegmentReturnsOriginalWhenUnderLimit()
     [Fact]
     public void ShortenNameSegmentReturnsOriginalAtExactLimit()
     {
-        var name = new string('a', 64);
+        var name = new string('a', 128);
         Assert.Equal(name, name.ShortenNameSegment());
     }
     [Fact]
     public void ShortenNameSegmentTruncatesAndAppendsHashWhenOverLimit()
     {
-        var longName = "MicrosoftGraphNetworkaccessDeviceReportWithStartDateTimeWithEndDateTimeWithDiscoveredApplicationSegmentId";
+        var longName = "MicrosoftGraphNetworkaccessDeviceReportWithStartDateTimeWithEndDateTimeWithDiscoveredApplicationSegmentIdWithApplicationIdWithAiAgentIdWithCloudApplicationName";
         var result = longName.ShortenNameSegment();
-        Assert.Equal(64, result.Length);
-        // First 55 chars are preserved (64 - 8 hash - 1 underscore)
-        Assert.StartsWith("MicrosoftGraphNetworkaccessDeviceReportWithStartDateTim", result);
+        Assert.Equal(128, result.Length);
+        // First 119 chars are preserved (128 - 8 hash - 1 underscore)
+        Assert.StartsWith("MicrosoftGraphNetworkaccessDeviceReportWithStartDateTimeWithEndDateTimeWithDiscoveredApplicationSegmentIdWithApplicatio", result);
         Assert.Contains("_", result);
     }
     [Fact]

tests/Kiota.Builder.Tests/Refiners/JavaLanguageRefinerTests.cs

@@ -791,11 +791,11 @@ public async Task ShortensOversizedNamespaceSegmentsAsync()
         var nameSegments = childNs.Name.Split('.');
         foreach (var segment in nameSegments)
         {
-            Assert.True(segment.Length <= 64, $"Segment '{segment}' exceeds 64 chars (length: {segment.Length})");
+            Assert.True(segment.Length <= 128, $"Segment '{segment}' exceeds 128 chars (length: {segment.Length})");
         }
 
         // Class name should be shortened
-        Assert.True(requestBuilderClass.Name.Length <= 64, $"Class name '{requestBuilderClass.Name}' exceeds 64 chars (length: {requestBuilderClass.Name.Length})");
+        Assert.True(requestBuilderClass.Name.Length <= 128, $"Class name '{requestBuilderClass.Name}' exceeds 128 chars (length: {requestBuilderClass.Name.Length})");
 
         // Doc comment should contain original name for disambiguation
         Assert.Contains("Original name:", requestBuilderClass.Documentation.DescriptionTemplate);
@@ -830,7 +830,7 @@ public async Task ShorteningIsDeterministicAsync()
     public async Task ShortenedClassNameIsReflectedInMethodReturnTypeAsync()
     {
         // Simulate: parent request builder has a method returning a child request builder with a long name
-        var longClassName = "MicrosoftGraphNetworkaccessDeviceReportWithStartDateTimeWithEndDateTimeRequestBuilder";
+        var longClassName = "MicrosoftGraphNetworkaccessDeviceReportWithStartDateTimeWithEndDateTimeWithDiscoveredApplicationSegmentIdWithApplicationIdRequestBuilder";
         var parentNs = root.AddNamespace("com.microsoft.graph.beta.networkaccess.reports");
         var longSegment = "microsoftgraphnetworkaccessdevicereportwithstartdatetimewithenddatetime";
         var childNs = root.AddNamespace($"com.microsoft.graph.beta.networkaccess.reports.{longSegment}");
@@ -861,11 +861,11 @@ public async Task ShortenedClassNameIsReflectedInMethodReturnTypeAsync()
         await ILanguageRefiner.RefineAsync(new GenerationConfiguration { Language = GenerationLanguage.Java }, root, cancellationToken: TestContext.Current.CancellationToken);
 
         // The class should be shortened
-        Assert.True(targetClass.Name.Length <= 64, $"Class name '{targetClass.Name}' exceeds 64 chars");
+        Assert.True(targetClass.Name.Length <= 128, $"Class name '{targetClass.Name}' exceeds 128 chars");
 
         // The method's return type should automatically reflect the shortened name via TypeDefinition
         Assert.Equal(targetClass.Name, returnType.Name);
-        Assert.True(returnType.Name.Length <= 64, $"Return type name '{returnType.Name}' exceeds 64 chars");
+        Assert.True(returnType.Name.Length <= 128, $"Return type name '{returnType.Name}' exceeds 128 chars");
     }
     [Fact]
     public async Task ShorteningWorksWhenDocumentationIsNullAsync()
@@ -883,7 +883,7 @@ public async Task ShorteningWorksWhenDocumentationIsNullAsync()
         await ILanguageRefiner.RefineAsync(new GenerationConfiguration { Language = GenerationLanguage.Java }, root, cancellationToken: TestContext.Current.CancellationToken);
 
         // Should shorten without throwing
-        Assert.True(requestBuilderClass.Name.Length <= 64);
+        Assert.True(requestBuilderClass.Name.Length <= 128);
     }
     #endregion
 }

tests/Kiota.Builder.Tests/Refiners/PhpLanguageRefinerTests.cs

@@ -319,18 +319,18 @@ public async Task ShortensOversizedNamespaceSegmentsAsync()
         // Namespace segment should be shortened
         foreach (var segment in childNs.Name.Split('.'))
         {
-            Assert.True(segment.Length <= 64, $"Segment '{segment}' exceeds 64 chars (length: {segment.Length})");
+            Assert.True(segment.Length <= 128, $"Segment '{segment}' exceeds 128 chars (length: {segment.Length})");
         }
 
         // Class name should be shortened
-        Assert.True(requestBuilderClass.Name.Length <= 64, $"Class name '{requestBuilderClass.Name}' exceeds 64 chars");
+        Assert.True(requestBuilderClass.Name.Length <= 128, $"Class name '{requestBuilderClass.Name}' exceeds 128 chars");
     }
     [Fact]
     public async Task ShortenedClassImportsAreConsistentAsync()
     {
         // Parent request builder references a child with a long name via method return type
         var parentNs = root.AddNamespace("ApiSdk.NetworkAccess.Reports");
-        var longSegment = "MicrosoftGraphNetworkaccessDeviceReportWithStartDateTimeWithEndDateTimeDiscoveredApplicationSegmentId";
+        var longSegment = "MicrosoftGraphNetworkaccessDeviceReportWithStartDateTimeWithEndDateTimeDiscoveredApplicationSegmentIdDiscoveredApplicationSegmentIdApplicationIdApplicationId";
         var childNs = root.AddNamespace($"ApiSdk.NetworkAccess.Reports.{longSegment}");
 
         var targetClass = childNs.AddClass(new CodeClass
@@ -363,7 +363,7 @@ public async Task ShortenedClassImportsAreConsistentAsync()
             var nsSegments = u.Name.Split('.');
             foreach (var seg in nsSegments)
             {
-                Assert.True(seg.Length <= 64, $"Using namespace segment '{seg}' exceeds 64 chars — stale pre-shortened name");
+                Assert.True(seg.Length <= 128, $"Using namespace segment '{seg}' exceeds 128 chars — stale pre-shortened name");
             }
         }
     }

tests/Kiota.Builder.Tests/Refiners/TypeScriptLanguageRefinerTests.cs

@@ -120,7 +120,7 @@ public async Task ShortensOversizedNamespaceSegmentsAsync()
         // TypeScript maps namespaces (not type names) to directories, so only segments are shortened.
         foreach (var segment in childNs.Name.Split('.'))
         {
-            Assert.True(segment.Length <= 64, $"Segment '{segment}' exceeds 64 chars (length: {segment.Length})");
+            Assert.True(segment.Length <= 128, $"Segment '{segment}' exceeds 128 chars (length: {segment.Length})");
         }
 
         // Type names must be left intact: TypeScript groups types into index.ts barrels and relies on