Codex/experimental stage detection

src/libs/AutoSDK.CLI/Commands/GenerateCommand.cs

@@ -270,6 +270,9 @@ private async Task HandleAsync(ParseResult parseResult)
             .Concat([Sources.Polyfills(settings)])
             .Concat([Sources.Exceptions(settings)])
             .Concat([Sources.PathBuilder(settings)])
+            .Concat(data.Methods.Any(static x => x.RawStream)
+                ? [Sources.ResponseStream(data.Converters.Settings)]
+                : [])
             .Concat([Sources.UnixTimestampJsonConverter(settings)])
             .Where(x => !x.IsEmpty)
             .ToArray();
@@ -290,4 +293,4 @@ private async Task HandleAsync(ParseResult parseResult)
 
         Console.WriteLine("Done.");
     }
-}
+}

src/libs/AutoSDK/Extensions/OpenApiExtensions.cs

@@ -154,7 +154,7 @@
             return (decimal.MinValue, decimal.MaxValue);
         }
 
         return schema.Format?.ToLowerInvariant() switch
         {
             "int32" => (int.MinValue, int.MaxValue),
             _ => (long.MinValue, long.MaxValue),
@@ -217,14 +217,14 @@
 
             if (schemeType == SecuritySchemeType.Http)
             {
                 schemeName = $"http_{namePart.ToLowerInvariant()}";
                 securityScheme.Type = SecuritySchemeType.Http;
                 securityScheme.Scheme = namePart;
                 securityScheme.In = location;
             }
             else
             {
                 schemeName = $"apikey_{namePart.ToLowerInvariant()}";
                 securityScheme.Type = schemeType;
                 securityScheme.In = location;
                 securityScheme.Name = namePart;
@@ -769,29 +769,90 @@
     {
         operation = operation ?? throw new ArgumentNullException(nameof(operation));
 
-        // In Microsoft.OpenApi 3.0, extension values are IOpenApiExtension, not JsonNode directly
-        // Check for specific extension keys instead
-        if ((operation.Extensions?.TryGetValue("x-stage", out var stage) ?? false) &&
-            stage is JsonValue stageJsonValue && stageJsonValue.TryGetValue<string>(out var stageString))
+        if (TryGetExtensionString(operation.Extensions, "x-stage", out var stageString))
         {
-            return stageString;
+            return NormalizeExperimentalStage(stageString);
         }
 
-        if ((operation.Extensions?.TryGetValue("x-alpha", out var alpha) ?? false) &&
-            alpha is JsonValue alphaJsonValue && alphaJsonValue.TryGetValue<bool>(out var alphaBoolean) && alphaBoolean)
+        if (TryGetExtensionBoolean(operation.Extensions, "x-alpha"))
         {
             return "Alpha";
         }
 
-        if ((operation.Extensions?.TryGetValue("x-beta", out var beta) ?? false) &&
-            beta is JsonValue betaJsonValue && betaJsonValue.TryGetValue<bool>(out var betaBoolean) && betaBoolean)
+        if (TryGetExtensionBoolean(operation.Extensions, "x-beta"))
         {
             return "Beta";
         }
 
+        if (TryGetAvailability(operation.Extensions, out var availability))
+        {
+            return NormalizeExperimentalStage(availability);
+        }
+
+        return GetExperimentalStageFromSummary(operation.Summary);
+    }
+
+    public static bool IsDeprecated(this OpenApiOperation operation)
+    {
+        operation = operation ?? throw new ArgumentNullException(nameof(operation));
+
+        return operation.Deprecated ||
+               TryGetAvailability(operation.Extensions, out var availability) &&
+               string.Equals(availability, "Deprecated", StringComparison.Ordinal);
+    }
+
+    public static bool IsDeprecated(this IOpenApiSchema schema)
+    {
+        schema = schema ?? throw new ArgumentNullException(nameof(schema));
+
+        return schema.Deprecated ||
+               TryGetAvailability(schema.Extensions, out var availability) &&
+               string.Equals(availability, "Deprecated", StringComparison.Ordinal);
+    }
+
+    public static string GetExperimentalStageFromSummary(this string? summary)
+    {
+        if (string.IsNullOrWhiteSpace(summary))
+        {
+            return string.Empty;
+        }
+
+        var trimmed = (summary ?? string.Empty).TrimStart();
+
+        foreach (var (prefix, stage) in ExperimentalStagePrefixes)
+        {
+            if (trimmed.StartsWith(prefix, StringComparison.OrdinalIgnoreCase))
+            {
+                return stage;
+            }
+        }
+
         return string.Empty;
     }
 
+    public static string StripExperimentalStagePrefix(this string? summary)
+    {
+        if (string.IsNullOrWhiteSpace(summary))
+        {
+            return string.Empty;
+        }
+
+        var trimmed = (summary ?? string.Empty).Trim();
+
+        foreach (var (prefix, _) in ExperimentalStagePrefixes)
+        {
+            if (!trimmed.StartsWith(prefix, StringComparison.OrdinalIgnoreCase))
+            {
+                continue;
+            }
+
+            var remainder = trimmed.Substring(prefix.Length).TrimStart(' ', '\t', ':', '-', '_');
+            return string.IsNullOrWhiteSpace(remainder) ? trimmed : remainder;
+        }
+
+        return trimmed;
+    }
+
     public static string ClearForXml(this string text)
     {
         text = text ?? throw new ArgumentNullException(nameof(text));
@@ -888,6 +949,142 @@
 
         return @enum;
     }
+
+    private static readonly (string Prefix, string Stage)[] ExperimentalStagePrefixes =
+    [
+        ("[Alpha]", "Alpha"),
+        ("[Beta]", "Beta"),
+        ("[Experimental]", "Experimental"),
+        ("Alpha", "Alpha"),
+        ("Beta", "Beta"),
+        ("Experimental", "Experimental"),
+    ];
+
+    private static string NormalizeExperimentalStage(string? stage)
+    {
+        var normalized = stage?.Trim() ?? string.Empty;
+        if (normalized.Length == 0)
+        {
+            return string.Empty;
+        }
+
+        return normalized.ToUpperInvariant() switch
+        {
+            "ALPHA" => "Alpha",
+            "BETA" => "Beta",
+            "EXPERIMENTAL" => "Experimental",
+            "GENERALLY-AVAILABLE" => string.Empty,
+            "DEPRECATED" => string.Empty,
+            _ => normalized,
+        };
+    }
+
+    private static string NormalizeAvailability(string? availability)
+    {
+        var normalized = availability?.Trim() ?? string.Empty;
+        if (normalized.Length == 0)
+        {
+            return string.Empty;
+        }
+
+        return normalized.ToUpperInvariant() switch
+        {
+            "ALPHA" => "Alpha",
+            "BETA" => "Beta",
+            "DEPRECATED" => "Deprecated",
+            "GENERALLY-AVAILABLE" => "GenerallyAvailable",
+            _ => normalized,
+        };
+    }
+
+    private static bool TryGetAvailability(IDictionary<string, IOpenApiExtension>? extensions, out string availability)
+    {
+        availability = string.Empty;
+
+        if (!TryGetExtensionString(extensions, "x-fern-availability", out var rawAvailability))
+        {
+            return false;
+        }
+
+        availability = NormalizeAvailability(rawAvailability);
+        return !string.IsNullOrWhiteSpace(availability);
+    }
+
+    private static bool TryGetExtensionString(
+        IDictionary<string, IOpenApiExtension>? extensions,
+        string name,
+        out string value)
+    {
+        value = string.Empty;
+
+        if (!(extensions?.TryGetValue(name, out var extension) ?? false))
+        {
+            return false;
+        }
+
+        if (TryGetJsonString(extension, out var stringValue))
+        {
+            value = stringValue;
+            return true;
+        }
+
+        return false;
+    }
+
+    private static bool TryGetExtensionBoolean(
+        IDictionary<string, IOpenApiExtension>? extensions,
+        string name)
+    {
+        if (!(extensions?.TryGetValue(name, out var extension) ?? false))
+        {
+            return false;
+        }
+
+        return TryGetJsonBoolean(extension, out var booleanValue) && booleanValue;
+    }
+
+    private static bool TryGetJsonString(IOpenApiExtension extension, out string value)
+    {
+        value = string.Empty;
+
+        var node = extension switch
+        {
+            JsonValue jsonValue => jsonValue,
+            JsonNodeExtension jsonNodeExtension => jsonNodeExtension.Node,
+            _ => null,
+        };
+
+        if (node is JsonValue stringNode &&
+            stringNode.TryGetValue<string>(out var stringValue) &&
+            !string.IsNullOrWhiteSpace(stringValue))
+        {
+            value = stringValue;
+            return true;
+        }
+
+        return false;
+    }
+
+    private static bool TryGetJsonBoolean(IOpenApiExtension extension, out bool value)
+    {
+        value = false;
+
+        var node = extension switch
+        {
+            JsonValue jsonValue => jsonValue,
+            JsonNodeExtension jsonNodeExtension => jsonNodeExtension.Node,
+            _ => null,
+        };
+
+        if (node is JsonValue booleanNode &&
+            booleanNode.TryGetValue<bool>(out var booleanValue))
+        {
+            value = booleanValue;
+            return true;
+        }
+
+        return false;
+    }
 
     public static Dictionary<string, PropertyData> ComputeEnum(
         this IList<JsonNode> @enum,
@@ -994,4 +1191,4 @@
             .Select(x => x.Value.OperationId!)
             .ToArray();
     }
-}
+}

src/libs/AutoSDK/Models/EndPoint.cs

@@ -226,7 +226,7 @@ public static EndPoint FromSchema(OperationContext operation, string? preferredM
                 operation.MethodName.FirstWord().ToLowerInvariant(),
             Settings: operation.Settings,
             GlobalSettings: operation.GlobalSettings,
-            IsDeprecated: operation.Operation.Deprecated,
+            IsDeprecated: operation.Operation.IsDeprecated(),
             ExperimentalStage: operation.Operation.GetExperimentalStage(),
             RequestType: requestType ?? TypeData.Default);
 

src/libs/AutoSDK/Models/MethodParameter.cs

@@ -94,7 +94,7 @@ public static MethodParameter FromSchemaContext(SchemaContext context)
             Style: parameter.Style,
             Explode: parameter.Explode,
             Settings: context.Settings,
-            IsDeprecated: context.Schema.Deprecated,
+            IsDeprecated: context.Schema.IsDeprecated(),
             DefaultValue: context.GetDefaultValue(),
             Summary: context.Schema.GetSummary(),
             Description:
@@ -228,4 +228,4 @@ public string ArgumentName
         ProducesDeprecationWarning
             ? "#pragma warning disable CS0618 // Type or member is obsolete"
             : " ";
-}
+}

src/libs/AutoSDK/Models/ModelData.cs

@@ -64,7 +64,7 @@ public static ModelData FromSchemaContext(
                 : [],
             Summary: context.Schema.GetSummary(),
             Description: context.Schema.Description ?? string.Empty,
-            IsDeprecated: context.Schema.Deprecated,
+            IsDeprecated: context.Schema.IsDeprecated(),
             BaseClass: context.IsDerivedClass
                 ? context.BaseClassContext.Id
                 : string.Empty,
@@ -96,4 +96,4 @@ public static ModelData FromSchemaContext(
     };
 
     public string FileNameWithoutExtension => $"{Namespace}.Models.{ExternalClassName}";
-}
+}

src/libs/AutoSDK/Models/PropertyData.cs

@@ -91,7 +91,7 @@ public static PropertyData FromSchemaContext(SchemaContext context)
             IsWriteOnly: context.Schema.WriteOnly,
             IsMultiPartFormDataFilename: false,
             Settings: context.Settings,
-            IsDeprecated: context.Schema.Deprecated,
+            IsDeprecated: context.Schema.IsDeprecated(),
             DefaultValue: context.Schema is { ReadOnly: true } && !type.CSharpTypeNullability
                 ? "default!"
                 : context.GetDefaultValue(),
@@ -187,4 +187,4 @@ public static PropertyData FromSchemaContext(SchemaContext context)
         .ReplaceIfEquals("void", "@void")
         .ReplaceIfEquals("volatile", "@volatile")
         .ReplaceIfEquals("while", "@while");
-}
+}

src/libs/AutoSDK/Models/TypeData.cs

@@ -198,7 +198,7 @@ Default with
             Namespace: type.StartsWith("global::System.", StringComparison.Ordinal)
                 ? "System"
                 : context.Settings.Namespace,
-            IsDeprecated: context.Schema.Deprecated,
+            IsDeprecated: context.Schema.IsDeprecated(),
             Settings: context.Settings);
     }
 
@@ -373,4 +373,4 @@ public static bool GetCSharpNullability(
                context.Schema.IsNullableAnyOf() || // anyOf: [X, {type: null}] is nullable
                !context.IsRequired && additionalContext?.IsRequired != true;
     }
-}
+}

src/libs/AutoSDK/Naming/Methods/SummaryGenerator.cs

@@ -11,6 +11,7 @@ public class SummaryGenerator : IMethodNameGenerator
         operation = operation ?? throw new ArgumentNullException(nameof(operation));
 
         var methodName = operation.Operation.Summary?
+            .StripExperimentalStagePrefix()
             .Replace("'", string.Empty)
             .Replace("’", string.Empty)
             .ToPropertyName()

src/libs/AutoSDK/Sources/Data.cs

@@ -198,7 +198,7 @@ public static Models.Data Prepare(
                     .Where(operation =>
                     {
                         if (settings.ExcludeDeprecatedOperations &&
-                            operation.Operation.Deprecated)
+                            operation.Operation.IsDeprecated())
                         {
                             return false;
                         }

src/libs/AutoSDK/Sources/Sources.Http.cs

@@ -45,7 +45,7 @@ public static string GenerateHttpRequest(OperationContext operation)
         var summary = !string.IsNullOrWhiteSpace(op.Summary)
             ? op.Summary
             : op.Description;
-        var deprecated = op.Deprecated ? "[DEPRECATED] " : "";
+        var deprecated = op.IsDeprecated() ? "[DEPRECATED] " : "";
         var title = !string.IsNullOrWhiteSpace(summary)
             ? string.Concat(deprecated, summary)
             : string.Concat(deprecated, method, " ", operation.OperationPath);