diff --git a/src/libs/OpenAI/Generated/AnyOf.2.g.cs b/src/libs/OpenAI/Generated/AnyOf.2.g.cs
index 4d2f603f..0d0fe722 100644
--- a/src/libs/OpenAI/Generated/AnyOf.2.g.cs
+++ b/src/libs/OpenAI/Generated/AnyOf.2.g.cs
@@ -267,5 +267,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AnyOf<T1, T2>?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AnyOf<T1, T2>),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AnyOf<T1, T2>?;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AnyOf<T1, T2>?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AnyOf<T1, T2>?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
diff --git a/src/libs/OpenAI/Generated/OneOf.1.g.cs b/src/libs/OpenAI/Generated/OneOf.1.g.cs
index f0bc28a1..691cc777 100644
--- a/src/libs/OpenAI/Generated/OneOf.1.g.cs
+++ b/src/libs/OpenAI/Generated/OneOf.1.g.cs
@@ -206,5 +206,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.OneOf<T1>?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.OneOf<T1>),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.OneOf<T1>?;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.OneOf<T1>?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.OneOf<T1>?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
diff --git a/src/libs/OpenAI/Generated/OneOf.2.g.cs b/src/libs/OpenAI/Generated/OneOf.2.g.cs
index e2945d1b..2c7bf8bc 100644
--- a/src/libs/OpenAI/Generated/OneOf.2.g.cs
+++ b/src/libs/OpenAI/Generated/OneOf.2.g.cs
@@ -267,5 +267,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.OneOf<T1, T2>?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.OneOf<T1, T2>),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.OneOf<T1, T2>?;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.OneOf<T1, T2>?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.OneOf<T1, T2>?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
diff --git a/src/libs/OpenAI/Generated/OneOf.3.g.cs b/src/libs/OpenAI/Generated/OneOf.3.g.cs
index 219ea4fb..bb7a99fc 100644
--- a/src/libs/OpenAI/Generated/OneOf.3.g.cs
+++ b/src/libs/OpenAI/Generated/OneOf.3.g.cs
@@ -318,5 +318,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.OneOf<T1, T2, T3>?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.OneOf<T1, T2, T3>),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.OneOf<T1, T2, T3>?;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.OneOf<T1, T2, T3>?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.OneOf<T1, T2, T3>?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
diff --git a/src/libs/OpenAI/Generated/OneOf.4.g.cs b/src/libs/OpenAI/Generated/OneOf.4.g.cs
index 60582ca4..066b42ce 100644
--- a/src/libs/OpenAI/Generated/OneOf.4.g.cs
+++ b/src/libs/OpenAI/Generated/OneOf.4.g.cs
@@ -369,5 +369,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.OneOf<T1, T2, T3, T4>?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.OneOf<T1, T2, T3, T4>),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.OneOf<T1, T2, T3, T4>?;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.OneOf<T1, T2, T3, T4>?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.OneOf<T1, T2, T3, T4>?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
diff --git a/src/libs/OpenAI/Generated/OneOf.5.g.cs b/src/libs/OpenAI/Generated/OneOf.5.g.cs
index 2d1f3893..565ba019 100644
--- a/src/libs/OpenAI/Generated/OneOf.5.g.cs
+++ b/src/libs/OpenAI/Generated/OneOf.5.g.cs
@@ -420,5 +420,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.OneOf<T1, T2, T3, T4, T5>?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.OneOf<T1, T2, T3, T4, T5>),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.OneOf<T1, T2, T3, T4, T5>?;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.OneOf<T1, T2, T3, T4, T5>?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.OneOf<T1, T2, T3, T4, T5>?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AddUploadPartRequest.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AddUploadPartRequest.g.cs
index ff50a105..1821f3b2 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AddUploadPartRequest.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AddUploadPartRequest.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AddUploadPartRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AddUploadPartRequest),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AddUploadPartRequest;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AddUploadPartRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AddUploadPartRequest?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AnnotationsItem.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AnnotationsItem.g.cs
index 88ca20cc..2733c5a6 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AnnotationsItem.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AnnotationsItem.g.cs
@@ -276,5 +276,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AnnotationsItem?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AnnotationsItem),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AnnotationsItem?;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AnnotationsItem?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AnnotationsItem?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AnnotationsItem2.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AnnotationsItem2.g.cs
index 61c2ff8d..af2f3c84 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AnnotationsItem2.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AnnotationsItem2.g.cs
@@ -276,5 +276,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AnnotationsItem2?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AnnotationsItem2),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AnnotationsItem2?;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AnnotationsItem2?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AnnotationsItem2?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantObject.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantObject.g.cs
index 8bed5ca0..fffe6ea8 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantObject.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantObject.g.cs
@@ -168,5 +168,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AssistantObject),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AssistantObject;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AssistantObject?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantObjectMetadata.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantObjectMetadata.g.cs
index 0236c8b3..7e063cff 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantObjectMetadata.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantObjectMetadata.g.cs
@@ -72,5 +72,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantObjectMetadata?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AssistantObjectMetadata),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AssistantObjectMetadata;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantObjectMetadata?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AssistantObjectMetadata?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantObjectToolDiscriminator.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantObjectToolDiscriminator.g.cs
index a2deeaa2..5600ec57 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantObjectToolDiscriminator.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantObjectToolDiscriminator.g.cs
@@ -78,5 +78,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantObjectToolDiscriminator?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AssistantObjectToolDiscriminator),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AssistantObjectToolDiscriminator;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantObjectToolDiscriminator?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AssistantObjectToolDiscriminator?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantObjectToolResources.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantObjectToolResources.g.cs
index a7b814d8..ee984e73 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantObjectToolResources.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantObjectToolResources.g.cs
@@ -83,5 +83,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantObjectToolResources?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AssistantObjectToolResources),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AssistantObjectToolResources;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantObjectToolResources?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AssistantObjectToolResources?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantObjectToolResourcesCodeInterpreter.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantObjectToolResourcesCodeInterpreter.g.cs
index a12bf345..39b6005f 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantObjectToolResourcesCodeInterpreter.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantObjectToolResourcesCodeInterpreter.g.cs
@@ -77,5 +77,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantObjectToolResourcesCodeInterpreter?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AssistantObjectToolResourcesCodeInterpreter),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AssistantObjectToolResourcesCodeInterpreter;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantObjectToolResourcesCodeInterpreter?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AssistantObjectToolResourcesCodeInterpreter?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantObjectToolResourcesFileSearch.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantObjectToolResourcesFileSearch.g.cs
index d853e1cd..f6f58ccf 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantObjectToolResourcesFileSearch.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantObjectToolResourcesFileSearch.g.cs
@@ -77,5 +77,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantObjectToolResourcesFileSearch?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AssistantObjectToolResourcesFileSearch),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AssistantObjectToolResourcesFileSearch;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantObjectToolResourcesFileSearch?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AssistantObjectToolResourcesFileSearch?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEvent.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEvent.g.cs
index 44e23245..1ee7501d 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEvent.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEvent.g.cs
@@ -1463,5 +1463,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantStreamEvent?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AssistantStreamEvent),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AssistantStreamEvent?;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantStreamEvent?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AssistantStreamEvent?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventDiscriminator.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventDiscriminator.g.cs
index c7db9d61..63d0fb6f 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventDiscriminator.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventDiscriminator.g.cs
@@ -78,5 +78,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantStreamEventDiscriminator?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AssistantStreamEventDiscriminator),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AssistantStreamEventDiscriminator;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantStreamEventDiscriminator?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AssistantStreamEventDiscriminator?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant10.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant10.g.cs
index e2f14073..3ca2865b 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant10.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant10.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantStreamEventVariant10?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AssistantStreamEventVariant10),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AssistantStreamEventVariant10;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantStreamEventVariant10?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AssistantStreamEventVariant10?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant11.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant11.g.cs
index 6f23b1d7..90cb323e 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant11.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant11.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantStreamEventVariant11?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AssistantStreamEventVariant11),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AssistantStreamEventVariant11;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantStreamEventVariant11?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AssistantStreamEventVariant11?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant12.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant12.g.cs
index 05dc620d..23fb45b8 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant12.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant12.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantStreamEventVariant12?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AssistantStreamEventVariant12),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AssistantStreamEventVariant12;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantStreamEventVariant12?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AssistantStreamEventVariant12?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant13.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant13.g.cs
index b9833ecb..fd7ddba2 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant13.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant13.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantStreamEventVariant13?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AssistantStreamEventVariant13),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AssistantStreamEventVariant13;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantStreamEventVariant13?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AssistantStreamEventVariant13?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant14.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant14.g.cs
index aef93468..22a9d01e 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant14.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant14.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantStreamEventVariant14?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AssistantStreamEventVariant14),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AssistantStreamEventVariant14;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantStreamEventVariant14?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AssistantStreamEventVariant14?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant15.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant15.g.cs
index 2462cb7d..0eb21bf8 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant15.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant15.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantStreamEventVariant15?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AssistantStreamEventVariant15),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AssistantStreamEventVariant15;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantStreamEventVariant15?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AssistantStreamEventVariant15?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant16.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant16.g.cs
index 082f55f9..91648dad 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant16.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant16.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantStreamEventVariant16?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AssistantStreamEventVariant16),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AssistantStreamEventVariant16;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantStreamEventVariant16?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AssistantStreamEventVariant16?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant17.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant17.g.cs
index 6df605ca..44a7199c 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant17.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant17.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantStreamEventVariant17?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AssistantStreamEventVariant17),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AssistantStreamEventVariant17;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantStreamEventVariant17?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AssistantStreamEventVariant17?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant18.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant18.g.cs
index 2f5c4455..85d528bc 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant18.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant18.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantStreamEventVariant18?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AssistantStreamEventVariant18),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AssistantStreamEventVariant18;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantStreamEventVariant18?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AssistantStreamEventVariant18?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant19.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant19.g.cs
index 4ff4f9b2..66a952c0 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant19.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant19.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantStreamEventVariant19?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AssistantStreamEventVariant19),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AssistantStreamEventVariant19;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantStreamEventVariant19?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AssistantStreamEventVariant19?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant20.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant20.g.cs
index 1d718795..1918809a 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant20.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant20.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantStreamEventVariant20?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AssistantStreamEventVariant20),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AssistantStreamEventVariant20;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantStreamEventVariant20?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AssistantStreamEventVariant20?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant21.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant21.g.cs
index 7a71c94e..33b860af 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant21.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant21.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantStreamEventVariant21?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AssistantStreamEventVariant21),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AssistantStreamEventVariant21;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantStreamEventVariant21?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AssistantStreamEventVariant21?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant22.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant22.g.cs
index 4a2fc8eb..70fbeef8 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant22.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant22.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantStreamEventVariant22?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AssistantStreamEventVariant22),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AssistantStreamEventVariant22;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantStreamEventVariant22?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AssistantStreamEventVariant22?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant23.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant23.g.cs
index 54dc4a12..181bbd56 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant23.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant23.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantStreamEventVariant23?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AssistantStreamEventVariant23),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AssistantStreamEventVariant23;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantStreamEventVariant23?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AssistantStreamEventVariant23?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant24.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant24.g.cs
index 9ae569d1..87f28ec2 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant24.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant24.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantStreamEventVariant24?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AssistantStreamEventVariant24),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AssistantStreamEventVariant24;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantStreamEventVariant24?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AssistantStreamEventVariant24?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant25.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant25.g.cs
index d4a87f06..5d5aee42 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant25.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant25.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantStreamEventVariant25?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AssistantStreamEventVariant25),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AssistantStreamEventVariant25;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantStreamEventVariant25?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AssistantStreamEventVariant25?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant3.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant3.g.cs
index efc62d43..d5b09226 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant3.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant3.g.cs
@@ -91,5 +91,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantStreamEventVariant3?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AssistantStreamEventVariant3),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AssistantStreamEventVariant3;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantStreamEventVariant3?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AssistantStreamEventVariant3?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant4.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant4.g.cs
index a63f97bb..77e308c2 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant4.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant4.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantStreamEventVariant4?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AssistantStreamEventVariant4),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AssistantStreamEventVariant4;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantStreamEventVariant4?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AssistantStreamEventVariant4?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant5.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant5.g.cs
index d244f292..ed06c734 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant5.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant5.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantStreamEventVariant5?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AssistantStreamEventVariant5),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AssistantStreamEventVariant5;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantStreamEventVariant5?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AssistantStreamEventVariant5?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant6.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant6.g.cs
index 8ec78a10..7b08c34f 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant6.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant6.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantStreamEventVariant6?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AssistantStreamEventVariant6),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AssistantStreamEventVariant6;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantStreamEventVariant6?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AssistantStreamEventVariant6?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant7.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant7.g.cs
index 25e93681..52636a9d 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant7.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant7.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantStreamEventVariant7?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AssistantStreamEventVariant7),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AssistantStreamEventVariant7;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantStreamEventVariant7?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AssistantStreamEventVariant7?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant8.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant8.g.cs
index 38a4d9b0..bceb6249 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant8.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant8.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantStreamEventVariant8?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AssistantStreamEventVariant8),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AssistantStreamEventVariant8;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantStreamEventVariant8?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AssistantStreamEventVariant8?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant9.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant9.g.cs
index 15b4eacd..e4d32638 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant9.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantStreamEventVariant9.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantStreamEventVariant9?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AssistantStreamEventVariant9),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AssistantStreamEventVariant9;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantStreamEventVariant9?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AssistantStreamEventVariant9?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantToolsCode.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantToolsCode.g.cs
index 2b7f88dc..7c231b4e 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantToolsCode.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantToolsCode.g.cs
@@ -78,5 +78,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantToolsCode?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AssistantToolsCode),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AssistantToolsCode;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantToolsCode?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AssistantToolsCode?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantToolsFileSearch.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantToolsFileSearch.g.cs
index aa1a086b..a35e2ea8 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantToolsFileSearch.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantToolsFileSearch.g.cs
@@ -84,5 +84,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantToolsFileSearch?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AssistantToolsFileSearch),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AssistantToolsFileSearch;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantToolsFileSearch?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AssistantToolsFileSearch?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantToolsFileSearchFileSearch.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantToolsFileSearchFileSearch.g.cs
index b88b8e6d..22ad0ff6 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantToolsFileSearchFileSearch.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantToolsFileSearchFileSearch.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantToolsFileSearchFileSearch?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AssistantToolsFileSearchFileSearch),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AssistantToolsFileSearchFileSearch;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantToolsFileSearchFileSearch?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AssistantToolsFileSearchFileSearch?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantToolsFileSearchTypeOnly.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantToolsFileSearchTypeOnly.g.cs
index 1640f0c3..87f2789c 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantToolsFileSearchTypeOnly.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantToolsFileSearchTypeOnly.g.cs
@@ -78,5 +78,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantToolsFileSearchTypeOnly?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AssistantToolsFileSearchTypeOnly),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AssistantToolsFileSearchTypeOnly;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantToolsFileSearchTypeOnly?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AssistantToolsFileSearchTypeOnly?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantToolsFunction.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantToolsFunction.g.cs
index b1be1670..84c0a8d0 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantToolsFunction.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantToolsFunction.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantToolsFunction?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AssistantToolsFunction),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AssistantToolsFunction;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantToolsFunction?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AssistantToolsFunction?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantsApiResponseFormatOption.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantsApiResponseFormatOption.g.cs
index ef43242e..a32883a2 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantsApiResponseFormatOption.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantsApiResponseFormatOption.g.cs
@@ -373,5 +373,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantsApiResponseFormatOption?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AssistantsApiResponseFormatOption),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AssistantsApiResponseFormatOption?;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantsApiResponseFormatOption?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AssistantsApiResponseFormatOption?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantsApiToolChoiceOption.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantsApiToolChoiceOption.g.cs
index cbf24038..14e9125b 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantsApiToolChoiceOption.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantsApiToolChoiceOption.g.cs
@@ -272,5 +272,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantsApiToolChoiceOption?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AssistantsApiToolChoiceOption),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AssistantsApiToolChoiceOption?;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantsApiToolChoiceOption?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AssistantsApiToolChoiceOption?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantsNamedToolChoice.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantsNamedToolChoice.g.cs
index c4837923..936598fa 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantsNamedToolChoice.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantsNamedToolChoice.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantsNamedToolChoice?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AssistantsNamedToolChoice),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AssistantsNamedToolChoice;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantsNamedToolChoice?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AssistantsNamedToolChoice?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantsNamedToolChoiceFunction.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantsNamedToolChoiceFunction.g.cs
index 59b0367a..e4fe56d3 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AssistantsNamedToolChoiceFunction.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AssistantsNamedToolChoiceFunction.g.cs
@@ -78,5 +78,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantsNamedToolChoiceFunction?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AssistantsNamedToolChoiceFunction),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AssistantsNamedToolChoiceFunction;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AssistantsNamedToolChoiceFunction?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AssistantsNamedToolChoiceFunction?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLog.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLog.g.cs
index f4569b0c..07674862 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLog.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLog.g.cs
@@ -215,5 +215,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLog?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AuditLog),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AuditLog;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLog?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AuditLog?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogActor.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogActor.g.cs
index d8592edd..83fc69be 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogActor.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogActor.g.cs
@@ -90,5 +90,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLogActor?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AuditLogActor),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AuditLogActor;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLogActor?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AuditLogActor?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogActorApiKey.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogActorApiKey.g.cs
index 23d9e7ec..848d7b85 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogActorApiKey.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogActorApiKey.g.cs
@@ -96,5 +96,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLogActorApiKey?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AuditLogActorApiKey),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AuditLogActorApiKey;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLogActorApiKey?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AuditLogActorApiKey?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogActorServiceAccount.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogActorServiceAccount.g.cs
index f60d5c85..5b479134 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogActorServiceAccount.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogActorServiceAccount.g.cs
@@ -77,5 +77,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLogActorServiceAccount?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AuditLogActorServiceAccount),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AuditLogActorServiceAccount;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLogActorServiceAccount?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AuditLogActorServiceAccount?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogActorSession.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogActorSession.g.cs
index c40ed6f3..a06a3ba3 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogActorSession.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogActorSession.g.cs
@@ -83,5 +83,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLogActorSession?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AuditLogActorSession),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AuditLogActorSession;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLogActorSession?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AuditLogActorSession?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogActorUser.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogActorUser.g.cs
index b9ef4707..36f00f52 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogActorUser.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogActorUser.g.cs
@@ -83,5 +83,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLogActorUser?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AuditLogActorUser),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AuditLogActorUser;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLogActorUser?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AuditLogActorUser?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogApiKeyCreated.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogApiKeyCreated.g.cs
index 5f38c95d..72851bdd 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogApiKeyCreated.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogApiKeyCreated.g.cs
@@ -83,5 +83,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLogApiKeyCreated?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AuditLogApiKeyCreated),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AuditLogApiKeyCreated;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLogApiKeyCreated?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AuditLogApiKeyCreated?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogApiKeyCreatedData.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogApiKeyCreatedData.g.cs
index c87bb686..ab9bac90 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogApiKeyCreatedData.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogApiKeyCreatedData.g.cs
@@ -77,5 +77,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLogApiKeyCreatedData?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AuditLogApiKeyCreatedData),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AuditLogApiKeyCreatedData;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLogApiKeyCreatedData?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AuditLogApiKeyCreatedData?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogApiKeyDeleted.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogApiKeyDeleted.g.cs
index 3d015ab3..0697d1dc 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogApiKeyDeleted.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogApiKeyDeleted.g.cs
@@ -77,5 +77,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLogApiKeyDeleted?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AuditLogApiKeyDeleted),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AuditLogApiKeyDeleted;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLogApiKeyDeleted?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AuditLogApiKeyDeleted?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogApiKeyUpdated.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogApiKeyUpdated.g.cs
index c4a22f88..84b79f0a 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogApiKeyUpdated.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogApiKeyUpdated.g.cs
@@ -83,5 +83,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLogApiKeyUpdated?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AuditLogApiKeyUpdated),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AuditLogApiKeyUpdated;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLogApiKeyUpdated?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AuditLogApiKeyUpdated?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogApiKeyUpdatedChangesRequested.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogApiKeyUpdatedChangesRequested.g.cs
index 0ca96d42..3f3eb74b 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogApiKeyUpdatedChangesRequested.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogApiKeyUpdatedChangesRequested.g.cs
@@ -77,5 +77,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLogApiKeyUpdatedChangesRequested?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AuditLogApiKeyUpdatedChangesRequested),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AuditLogApiKeyUpdatedChangesRequested;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLogApiKeyUpdatedChangesRequested?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AuditLogApiKeyUpdatedChangesRequested?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogInviteAccepted.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogInviteAccepted.g.cs
index 222d338f..48641bb4 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogInviteAccepted.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogInviteAccepted.g.cs
@@ -77,5 +77,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLogInviteAccepted?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AuditLogInviteAccepted),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AuditLogInviteAccepted;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLogInviteAccepted?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AuditLogInviteAccepted?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogInviteDeleted.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogInviteDeleted.g.cs
index 46051f29..a01b4b51 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogInviteDeleted.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogInviteDeleted.g.cs
@@ -77,5 +77,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLogInviteDeleted?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AuditLogInviteDeleted),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AuditLogInviteDeleted;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLogInviteDeleted?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AuditLogInviteDeleted?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogInviteSent.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogInviteSent.g.cs
index 7c83f6f7..fb8d7d8f 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogInviteSent.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogInviteSent.g.cs
@@ -83,5 +83,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLogInviteSent?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AuditLogInviteSent),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AuditLogInviteSent;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLogInviteSent?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AuditLogInviteSent?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogInviteSentData.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogInviteSentData.g.cs
index 93495293..1111f887 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogInviteSentData.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogInviteSentData.g.cs
@@ -83,5 +83,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLogInviteSentData?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AuditLogInviteSentData),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AuditLogInviteSentData;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLogInviteSentData?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AuditLogInviteSentData?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogLoginFailed.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogLoginFailed.g.cs
index 46a1ea6b..aca79105 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogLoginFailed.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogLoginFailed.g.cs
@@ -83,5 +83,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLogLoginFailed?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AuditLogLoginFailed),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AuditLogLoginFailed;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLogLoginFailed?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AuditLogLoginFailed?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogLogoutFailed.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogLogoutFailed.g.cs
index e83c7438..84886dfd 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogLogoutFailed.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogLogoutFailed.g.cs
@@ -83,5 +83,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLogLogoutFailed?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AuditLogLogoutFailed),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AuditLogLogoutFailed;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLogLogoutFailed?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AuditLogLogoutFailed?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogOrganizationUpdated.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogOrganizationUpdated.g.cs
index bd475e02..bf985adb 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogOrganizationUpdated.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogOrganizationUpdated.g.cs
@@ -83,5 +83,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLogOrganizationUpdated?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AuditLogOrganizationUpdated),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AuditLogOrganizationUpdated;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLogOrganizationUpdated?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AuditLogOrganizationUpdated?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogOrganizationUpdatedChangesRequested.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogOrganizationUpdatedChangesRequested.g.cs
index 7ce1cd20..90dc7f56 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogOrganizationUpdatedChangesRequested.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogOrganizationUpdatedChangesRequested.g.cs
@@ -95,5 +95,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLogOrganizationUpdatedChangesRequested?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AuditLogOrganizationUpdatedChangesRequested),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AuditLogOrganizationUpdatedChangesRequested;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLogOrganizationUpdatedChangesRequested?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AuditLogOrganizationUpdatedChangesRequested?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogOrganizationUpdatedChangesRequestedSettings.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogOrganizationUpdatedChangesRequestedSettings.g.cs
index 762aa1f1..7a6139be 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogOrganizationUpdatedChangesRequestedSettings.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogOrganizationUpdatedChangesRequestedSettings.g.cs
@@ -83,5 +83,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLogOrganizationUpdatedChangesRequestedSettings?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AuditLogOrganizationUpdatedChangesRequestedSettings),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AuditLogOrganizationUpdatedChangesRequestedSettings;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLogOrganizationUpdatedChangesRequestedSettings?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AuditLogOrganizationUpdatedChangesRequestedSettings?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogProject.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogProject.g.cs
index 326543d2..a2ddf7c2 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogProject.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogProject.g.cs
@@ -83,5 +83,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLogProject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AuditLogProject),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AuditLogProject;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLogProject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AuditLogProject?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogProjectArchived.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogProjectArchived.g.cs
index a6890319..29039bbb 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogProjectArchived.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogProjectArchived.g.cs
@@ -77,5 +77,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLogProjectArchived?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AuditLogProjectArchived),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AuditLogProjectArchived;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLogProjectArchived?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AuditLogProjectArchived?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogProjectCreated.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogProjectCreated.g.cs
index c83e78d0..23e84512 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogProjectCreated.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogProjectCreated.g.cs
@@ -83,5 +83,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLogProjectCreated?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AuditLogProjectCreated),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AuditLogProjectCreated;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLogProjectCreated?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AuditLogProjectCreated?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogProjectCreatedData.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogProjectCreatedData.g.cs
index 27699c36..20e0b70d 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogProjectCreatedData.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogProjectCreatedData.g.cs
@@ -83,5 +83,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLogProjectCreatedData?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AuditLogProjectCreatedData),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AuditLogProjectCreatedData;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLogProjectCreatedData?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AuditLogProjectCreatedData?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogProjectUpdated.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogProjectUpdated.g.cs
index eff20c3d..64bd1b9c 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogProjectUpdated.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogProjectUpdated.g.cs
@@ -83,5 +83,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLogProjectUpdated?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AuditLogProjectUpdated),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AuditLogProjectUpdated;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLogProjectUpdated?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AuditLogProjectUpdated?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogProjectUpdatedChangesRequested.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogProjectUpdatedChangesRequested.g.cs
index 9031554b..40e1719a 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogProjectUpdatedChangesRequested.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogProjectUpdatedChangesRequested.g.cs
@@ -77,5 +77,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLogProjectUpdatedChangesRequested?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AuditLogProjectUpdatedChangesRequested),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AuditLogProjectUpdatedChangesRequested;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLogProjectUpdatedChangesRequested?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AuditLogProjectUpdatedChangesRequested?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogServiceAccountCreated.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogServiceAccountCreated.g.cs
index a2e68376..76be6c95 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogServiceAccountCreated.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogServiceAccountCreated.g.cs
@@ -83,5 +83,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLogServiceAccountCreated?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AuditLogServiceAccountCreated),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AuditLogServiceAccountCreated;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLogServiceAccountCreated?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AuditLogServiceAccountCreated?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogServiceAccountCreatedData.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogServiceAccountCreatedData.g.cs
index 8f9d0f4b..f7c98017 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogServiceAccountCreatedData.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogServiceAccountCreatedData.g.cs
@@ -77,5 +77,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLogServiceAccountCreatedData?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AuditLogServiceAccountCreatedData),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AuditLogServiceAccountCreatedData;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLogServiceAccountCreatedData?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AuditLogServiceAccountCreatedData?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogServiceAccountDeleted.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogServiceAccountDeleted.g.cs
index 40d668ef..a209151a 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogServiceAccountDeleted.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogServiceAccountDeleted.g.cs
@@ -77,5 +77,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLogServiceAccountDeleted?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AuditLogServiceAccountDeleted),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AuditLogServiceAccountDeleted;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLogServiceAccountDeleted?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AuditLogServiceAccountDeleted?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogServiceAccountUpdated.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogServiceAccountUpdated.g.cs
index 4b9d87ba..67ec32d0 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogServiceAccountUpdated.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogServiceAccountUpdated.g.cs
@@ -83,5 +83,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLogServiceAccountUpdated?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AuditLogServiceAccountUpdated),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AuditLogServiceAccountUpdated;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLogServiceAccountUpdated?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AuditLogServiceAccountUpdated?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogServiceAccountUpdatedChangesRequested.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogServiceAccountUpdatedChangesRequested.g.cs
index 6bde445b..e6e32277 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogServiceAccountUpdatedChangesRequested.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogServiceAccountUpdatedChangesRequested.g.cs
@@ -77,5 +77,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLogServiceAccountUpdatedChangesRequested?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AuditLogServiceAccountUpdatedChangesRequested),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AuditLogServiceAccountUpdatedChangesRequested;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLogServiceAccountUpdatedChangesRequested?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AuditLogServiceAccountUpdatedChangesRequested?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogUserAdded.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogUserAdded.g.cs
index 8e2bd0fd..7329fcbd 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogUserAdded.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogUserAdded.g.cs
@@ -83,5 +83,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLogUserAdded?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AuditLogUserAdded),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AuditLogUserAdded;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLogUserAdded?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AuditLogUserAdded?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogUserAddedData.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogUserAddedData.g.cs
index 28a7c347..deb6bc1a 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogUserAddedData.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogUserAddedData.g.cs
@@ -77,5 +77,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLogUserAddedData?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AuditLogUserAddedData),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AuditLogUserAddedData;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLogUserAddedData?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AuditLogUserAddedData?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogUserDeleted.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogUserDeleted.g.cs
index 9131e436..3b303f52 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogUserDeleted.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogUserDeleted.g.cs
@@ -77,5 +77,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLogUserDeleted?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AuditLogUserDeleted),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AuditLogUserDeleted;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLogUserDeleted?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AuditLogUserDeleted?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogUserUpdated.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogUserUpdated.g.cs
index 9b104fa4..8d6971c6 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogUserUpdated.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogUserUpdated.g.cs
@@ -83,5 +83,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLogUserUpdated?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AuditLogUserUpdated),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AuditLogUserUpdated;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLogUserUpdated?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AuditLogUserUpdated?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogUserUpdatedChangesRequested.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogUserUpdatedChangesRequested.g.cs
index 8e432016..0ed85787 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogUserUpdatedChangesRequested.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AuditLogUserUpdatedChangesRequested.g.cs
@@ -77,5 +77,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLogUserUpdatedChangesRequested?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AuditLogUserUpdatedChangesRequested),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AuditLogUserUpdatedChangesRequested;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AuditLogUserUpdatedChangesRequested?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AuditLogUserUpdatedChangesRequested?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.AutoChunkingStrategyRequestParam.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.AutoChunkingStrategyRequestParam.g.cs
index f03f15d1..db95463b 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.AutoChunkingStrategyRequestParam.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.AutoChunkingStrategyRequestParam.g.cs
@@ -78,5 +78,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.AutoChunkingStrategyRequestParam?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.AutoChunkingStrategyRequestParam),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.AutoChunkingStrategyRequestParam;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.AutoChunkingStrategyRequestParam?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.AutoChunkingStrategyRequestParam?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.Batch.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.Batch.g.cs
index aa050916..ef395737 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.Batch.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.Batch.g.cs
@@ -208,5 +208,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.Batch?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.Batch),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.Batch;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.Batch?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.Batch?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.BatchErrors.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.BatchErrors.g.cs
index 5e8b209a..8639498e 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.BatchErrors.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.BatchErrors.g.cs
@@ -83,5 +83,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.BatchErrors?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.BatchErrors),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.BatchErrors;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.BatchErrors?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.BatchErrors?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.BatchErrorsDataItem.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.BatchErrorsDataItem.g.cs
index 7fe92c9b..69cdeae9 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.BatchErrorsDataItem.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.BatchErrorsDataItem.g.cs
@@ -95,5 +95,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.BatchErrorsDataItem?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.BatchErrorsDataItem),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.BatchErrorsDataItem;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.BatchErrorsDataItem?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.BatchErrorsDataItem?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.BatchMetadata.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.BatchMetadata.g.cs
index 68f887d3..7ab93170 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.BatchMetadata.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.BatchMetadata.g.cs
@@ -72,5 +72,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.BatchMetadata?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.BatchMetadata),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.BatchMetadata;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.BatchMetadata?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.BatchMetadata?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.BatchRequestCounts.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.BatchRequestCounts.g.cs
index aadac92e..e63b6c59 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.BatchRequestCounts.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.BatchRequestCounts.g.cs
@@ -92,5 +92,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.BatchRequestCounts?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.BatchRequestCounts),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.BatchRequestCounts;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.BatchRequestCounts?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.BatchRequestCounts?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.BatchRequestInput.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.BatchRequestInput.g.cs
index 888b961b..0b3ed79d 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.BatchRequestInput.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.BatchRequestInput.g.cs
@@ -90,5 +90,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.BatchRequestInput?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.BatchRequestInput),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.BatchRequestInput;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.BatchRequestInput?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.BatchRequestInput?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.BatchRequestOutput.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.BatchRequestOutput.g.cs
index 1df5961f..d5950e33 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.BatchRequestOutput.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.BatchRequestOutput.g.cs
@@ -95,5 +95,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.BatchRequestOutput?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.BatchRequestOutput),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.BatchRequestOutput;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.BatchRequestOutput?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.BatchRequestOutput?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.BatchRequestOutputError.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.BatchRequestOutputError.g.cs
index edb416dc..06a7f1f5 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.BatchRequestOutputError.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.BatchRequestOutputError.g.cs
@@ -83,5 +83,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.BatchRequestOutputError?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.BatchRequestOutputError),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.BatchRequestOutputError;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.BatchRequestOutputError?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.BatchRequestOutputError?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.BatchRequestOutputResponse.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.BatchRequestOutputResponse.g.cs
index 562f71e2..a861b04a 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.BatchRequestOutputResponse.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.BatchRequestOutputResponse.g.cs
@@ -89,5 +89,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.BatchRequestOutputResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.BatchRequestOutputResponse),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.BatchRequestOutputResponse;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.BatchRequestOutputResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.BatchRequestOutputResponse?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.BatchRequestOutputResponseBody.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.BatchRequestOutputResponseBody.g.cs
index 4a9a965c..8e7e71a4 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.BatchRequestOutputResponseBody.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.BatchRequestOutputResponseBody.g.cs
@@ -72,5 +72,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.BatchRequestOutputResponseBody?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.BatchRequestOutputResponseBody),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.BatchRequestOutputResponseBody;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.BatchRequestOutputResponseBody?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.BatchRequestOutputResponseBody?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CancelUploadRequest.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CancelUploadRequest.g.cs
index ff4374d1..0aab125d 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CancelUploadRequest.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CancelUploadRequest.g.cs
@@ -72,5 +72,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CancelUploadRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CancelUploadRequest),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CancelUploadRequest;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CancelUploadRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CancelUploadRequest?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionFunctionCallOption.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionFunctionCallOption.g.cs
index 49f51ac2..f82b236d 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionFunctionCallOption.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionFunctionCallOption.g.cs
@@ -78,5 +78,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionFunctionCallOption?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ChatCompletionFunctionCallOption),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ChatCompletionFunctionCallOption;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionFunctionCallOption?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ChatCompletionFunctionCallOption?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionFunctions.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionFunctions.g.cs
index e0aae7f3..c5ce0ee9 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionFunctions.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionFunctions.g.cs
@@ -95,5 +95,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionFunctions?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ChatCompletionFunctions),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ChatCompletionFunctions;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionFunctions?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ChatCompletionFunctions?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionMessageToolCall.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionMessageToolCall.g.cs
index 462d68f6..f95a79dc 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionMessageToolCall.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionMessageToolCall.g.cs
@@ -92,5 +92,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionMessageToolCall?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ChatCompletionMessageToolCall),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ChatCompletionMessageToolCall;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionMessageToolCall?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ChatCompletionMessageToolCall?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionMessageToolCallChunk.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionMessageToolCallChunk.g.cs
index d7415404..0307234c 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionMessageToolCallChunk.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionMessageToolCallChunk.g.cs
@@ -97,5 +97,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionMessageToolCallChunk?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ChatCompletionMessageToolCallChunk),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ChatCompletionMessageToolCallChunk;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionMessageToolCallChunk?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ChatCompletionMessageToolCallChunk?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionMessageToolCallChunkFunction.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionMessageToolCallChunkFunction.g.cs
index df47b3b0..6fc9cf50 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionMessageToolCallChunkFunction.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionMessageToolCallChunkFunction.g.cs
@@ -83,5 +83,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionMessageToolCallChunkFunction?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ChatCompletionMessageToolCallChunkFunction),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ChatCompletionMessageToolCallChunkFunction;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionMessageToolCallChunkFunction?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ChatCompletionMessageToolCallChunkFunction?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionMessageToolCallFunction.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionMessageToolCallFunction.g.cs
index 4be829fd..3864da07 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionMessageToolCallFunction.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionMessageToolCallFunction.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionMessageToolCallFunction?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ChatCompletionMessageToolCallFunction),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ChatCompletionMessageToolCallFunction;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionMessageToolCallFunction?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ChatCompletionMessageToolCallFunction?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionNamedToolChoice.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionNamedToolChoice.g.cs
index 0983f9dc..2ad865be 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionNamedToolChoice.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionNamedToolChoice.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionNamedToolChoice?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ChatCompletionNamedToolChoice),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ChatCompletionNamedToolChoice;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionNamedToolChoice?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ChatCompletionNamedToolChoice?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionNamedToolChoiceFunction.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionNamedToolChoiceFunction.g.cs
index d06d97ed..8a94bfad 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionNamedToolChoiceFunction.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionNamedToolChoiceFunction.g.cs
@@ -78,5 +78,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionNamedToolChoiceFunction?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ChatCompletionNamedToolChoiceFunction),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ChatCompletionNamedToolChoiceFunction;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionNamedToolChoiceFunction?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ChatCompletionNamedToolChoiceFunction?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestAssistantMessage.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestAssistantMessage.g.cs
index 379ef1e5..09911d1b 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestAssistantMessage.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestAssistantMessage.g.cs
@@ -119,5 +119,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionRequestAssistantMessage?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ChatCompletionRequestAssistantMessage),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ChatCompletionRequestAssistantMessage;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionRequestAssistantMessage?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ChatCompletionRequestAssistantMessage?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestAssistantMessageAudio.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestAssistantMessageAudio.g.cs
index 118201fd..2f903f5b 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestAssistantMessageAudio.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestAssistantMessageAudio.g.cs
@@ -79,5 +79,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionRequestAssistantMessageAudio?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ChatCompletionRequestAssistantMessageAudio),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ChatCompletionRequestAssistantMessageAudio;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionRequestAssistantMessageAudio?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ChatCompletionRequestAssistantMessageAudio?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestAssistantMessageContentPart.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestAssistantMessageContentPart.g.cs
index e36c0d24..925057ad 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestAssistantMessageContentPart.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestAssistantMessageContentPart.g.cs
@@ -276,5 +276,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionRequestAssistantMessageContentPart?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ChatCompletionRequestAssistantMessageContentPart),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ChatCompletionRequestAssistantMessageContentPart?;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionRequestAssistantMessageContentPart?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ChatCompletionRequestAssistantMessageContentPart?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestAssistantMessageContentPartDiscriminator.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestAssistantMessageContentPartDiscriminator.g.cs
index e78256d7..3f8f2d3b 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestAssistantMessageContentPartDiscriminator.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestAssistantMessageContentPartDiscriminator.g.cs
@@ -78,5 +78,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionRequestAssistantMessageContentPartDiscriminator?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ChatCompletionRequestAssistantMessageContentPartDiscriminator),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ChatCompletionRequestAssistantMessageContentPartDiscriminator;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionRequestAssistantMessageContentPartDiscriminator?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ChatCompletionRequestAssistantMessageContentPartDiscriminator?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestAssistantMessageFunctionCall.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestAssistantMessageFunctionCall.g.cs
index 32f4457f..0e49af72 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestAssistantMessageFunctionCall.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestAssistantMessageFunctionCall.g.cs
@@ -88,5 +88,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionRequestAssistantMessageFunctionCall?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ChatCompletionRequestAssistantMessageFunctionCall),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ChatCompletionRequestAssistantMessageFunctionCall;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionRequestAssistantMessageFunctionCall?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ChatCompletionRequestAssistantMessageFunctionCall?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestFunctionMessage.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestFunctionMessage.g.cs
index 03c6e770..307ee840 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestFunctionMessage.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestFunctionMessage.g.cs
@@ -96,5 +96,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionRequestFunctionMessage?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ChatCompletionRequestFunctionMessage),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ChatCompletionRequestFunctionMessage;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionRequestFunctionMessage?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ChatCompletionRequestFunctionMessage?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestMessage.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestMessage.g.cs
index 44798379..6b4b2e10 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestMessage.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestMessage.g.cs
@@ -429,5 +429,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionRequestMessage?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ChatCompletionRequestMessage),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ChatCompletionRequestMessage?;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionRequestMessage?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ChatCompletionRequestMessage?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestMessageContentPartAudio.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestMessageContentPartAudio.g.cs
index 3ee4efc2..0cebd4df 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestMessageContentPartAudio.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestMessageContentPartAudio.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionRequestMessageContentPartAudio?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ChatCompletionRequestMessageContentPartAudio),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ChatCompletionRequestMessageContentPartAudio;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionRequestMessageContentPartAudio?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ChatCompletionRequestMessageContentPartAudio?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestMessageContentPartAudioInputAudio.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestMessageContentPartAudioInputAudio.g.cs
index dc0342e8..dadf7025 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestMessageContentPartAudioInputAudio.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestMessageContentPartAudioInputAudio.g.cs
@@ -86,5 +86,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionRequestMessageContentPartAudioInputAudio?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ChatCompletionRequestMessageContentPartAudioInputAudio),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ChatCompletionRequestMessageContentPartAudioInputAudio;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionRequestMessageContentPartAudioInputAudio?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ChatCompletionRequestMessageContentPartAudioInputAudio?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestMessageContentPartImage.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestMessageContentPartImage.g.cs
index 9f598913..a3dc3f47 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestMessageContentPartImage.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestMessageContentPartImage.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionRequestMessageContentPartImage?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ChatCompletionRequestMessageContentPartImage),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ChatCompletionRequestMessageContentPartImage;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionRequestMessageContentPartImage?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ChatCompletionRequestMessageContentPartImage?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestMessageContentPartImageImageUrl.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestMessageContentPartImageImageUrl.g.cs
index 5f4a089e..efbe5767 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestMessageContentPartImageImageUrl.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestMessageContentPartImageImageUrl.g.cs
@@ -86,5 +86,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionRequestMessageContentPartImageImageUrl?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ChatCompletionRequestMessageContentPartImageImageUrl),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ChatCompletionRequestMessageContentPartImageImageUrl;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionRequestMessageContentPartImageImageUrl?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ChatCompletionRequestMessageContentPartImageImageUrl?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestMessageContentPartRefusal.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestMessageContentPartRefusal.g.cs
index 3205b1ef..da1a0fd3 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestMessageContentPartRefusal.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestMessageContentPartRefusal.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionRequestMessageContentPartRefusal?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ChatCompletionRequestMessageContentPartRefusal),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ChatCompletionRequestMessageContentPartRefusal;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionRequestMessageContentPartRefusal?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ChatCompletionRequestMessageContentPartRefusal?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestMessageContentPartText.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestMessageContentPartText.g.cs
index 0ba30265..8011a344 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestMessageContentPartText.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestMessageContentPartText.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionRequestMessageContentPartText?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ChatCompletionRequestMessageContentPartText),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ChatCompletionRequestMessageContentPartText;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionRequestMessageContentPartText?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ChatCompletionRequestMessageContentPartText?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestMessageDiscriminator.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestMessageDiscriminator.g.cs
index 49d6056a..908517f3 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestMessageDiscriminator.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestMessageDiscriminator.g.cs
@@ -78,5 +78,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionRequestMessageDiscriminator?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ChatCompletionRequestMessageDiscriminator),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ChatCompletionRequestMessageDiscriminator;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionRequestMessageDiscriminator?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ChatCompletionRequestMessageDiscriminator?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestSystemMessage.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestSystemMessage.g.cs
index 8e0f2d49..cf9a51bd 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestSystemMessage.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestSystemMessage.g.cs
@@ -94,5 +94,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionRequestSystemMessage?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ChatCompletionRequestSystemMessage),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ChatCompletionRequestSystemMessage;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionRequestSystemMessage?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ChatCompletionRequestSystemMessage?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestSystemMessageContentPart.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestSystemMessageContentPart.g.cs
index 4b8da906..9ea98881 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestSystemMessageContentPart.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestSystemMessageContentPart.g.cs
@@ -207,5 +207,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionRequestSystemMessageContentPart?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ChatCompletionRequestSystemMessageContentPart),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ChatCompletionRequestSystemMessageContentPart?;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionRequestSystemMessageContentPart?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ChatCompletionRequestSystemMessageContentPart?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestToolMessage.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestToolMessage.g.cs
index c3147f18..222304c3 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestToolMessage.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestToolMessage.g.cs
@@ -95,5 +95,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionRequestToolMessage?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ChatCompletionRequestToolMessage),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ChatCompletionRequestToolMessage;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionRequestToolMessage?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ChatCompletionRequestToolMessage?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestToolMessageContentPart.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestToolMessageContentPart.g.cs
index 82ea4914..a65dedb0 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestToolMessageContentPart.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestToolMessageContentPart.g.cs
@@ -207,5 +207,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionRequestToolMessageContentPart?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ChatCompletionRequestToolMessageContentPart),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ChatCompletionRequestToolMessageContentPart?;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionRequestToolMessageContentPart?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ChatCompletionRequestToolMessageContentPart?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestUserMessage.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestUserMessage.g.cs
index f17b9968..b1eb2674 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestUserMessage.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestUserMessage.g.cs
@@ -94,5 +94,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionRequestUserMessage?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ChatCompletionRequestUserMessage),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ChatCompletionRequestUserMessage;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionRequestUserMessage?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ChatCompletionRequestUserMessage?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestUserMessageContentPart.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestUserMessageContentPart.g.cs
index 6e16fa9e..809c708e 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestUserMessageContentPart.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestUserMessageContentPart.g.cs
@@ -327,5 +327,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionRequestUserMessageContentPart?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ChatCompletionRequestUserMessageContentPart),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ChatCompletionRequestUserMessageContentPart?;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionRequestUserMessageContentPart?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ChatCompletionRequestUserMessageContentPart?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestUserMessageContentPartDiscriminator.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestUserMessageContentPartDiscriminator.g.cs
index 202eef1a..55fc5fc6 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestUserMessageContentPartDiscriminator.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionRequestUserMessageContentPartDiscriminator.g.cs
@@ -78,5 +78,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionRequestUserMessageContentPartDiscriminator?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ChatCompletionRequestUserMessageContentPartDiscriminator),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ChatCompletionRequestUserMessageContentPartDiscriminator;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionRequestUserMessageContentPartDiscriminator?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ChatCompletionRequestUserMessageContentPartDiscriminator?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionResponseMessage.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionResponseMessage.g.cs
index 48698dc3..8c2c9413 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionResponseMessage.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionResponseMessage.g.cs
@@ -110,5 +110,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionResponseMessage?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ChatCompletionResponseMessage),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ChatCompletionResponseMessage;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionResponseMessage?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ChatCompletionResponseMessage?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionResponseMessageAudio.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionResponseMessageAudio.g.cs
index c0cc0b50..4fdb393b 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionResponseMessageAudio.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionResponseMessageAudio.g.cs
@@ -104,5 +104,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionResponseMessageAudio?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ChatCompletionResponseMessageAudio),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ChatCompletionResponseMessageAudio;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionResponseMessageAudio?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ChatCompletionResponseMessageAudio?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionResponseMessageFunctionCall.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionResponseMessageFunctionCall.g.cs
index 93ee9961..9dd48481 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionResponseMessageFunctionCall.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionResponseMessageFunctionCall.g.cs
@@ -88,5 +88,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionResponseMessageFunctionCall?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ChatCompletionResponseMessageFunctionCall),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ChatCompletionResponseMessageFunctionCall;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionResponseMessageFunctionCall?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ChatCompletionResponseMessageFunctionCall?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionStreamOptions.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionStreamOptions.g.cs
index 70bf9a2f..fa9b4569 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionStreamOptions.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionStreamOptions.g.cs
@@ -77,5 +77,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionStreamOptions?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ChatCompletionStreamOptions),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ChatCompletionStreamOptions;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionStreamOptions?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ChatCompletionStreamOptions?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionStreamResponseDelta.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionStreamResponseDelta.g.cs
index 6108e915..e47aa2b8 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionStreamResponseDelta.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionStreamResponseDelta.g.cs
@@ -103,5 +103,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionStreamResponseDelta?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ChatCompletionStreamResponseDelta),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ChatCompletionStreamResponseDelta;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionStreamResponseDelta?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ChatCompletionStreamResponseDelta?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionStreamResponseDeltaFunctionCall.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionStreamResponseDeltaFunctionCall.g.cs
index cbd93326..9bbe98bd 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionStreamResponseDeltaFunctionCall.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionStreamResponseDeltaFunctionCall.g.cs
@@ -86,5 +86,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionStreamResponseDeltaFunctionCall?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ChatCompletionStreamResponseDeltaFunctionCall),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ChatCompletionStreamResponseDeltaFunctionCall;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionStreamResponseDeltaFunctionCall?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ChatCompletionStreamResponseDeltaFunctionCall?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionTokenLogprob.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionTokenLogprob.g.cs
index f5e621e6..d598dc14 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionTokenLogprob.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionTokenLogprob.g.cs
@@ -99,5 +99,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionTokenLogprob?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ChatCompletionTokenLogprob),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ChatCompletionTokenLogprob;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionTokenLogprob?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ChatCompletionTokenLogprob?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionTokenLogprobTopLogprob.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionTokenLogprobTopLogprob.g.cs
index 4c3a33de..598b2752 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionTokenLogprobTopLogprob.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionTokenLogprobTopLogprob.g.cs
@@ -92,5 +92,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionTokenLogprobTopLogprob?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ChatCompletionTokenLogprobTopLogprob),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ChatCompletionTokenLogprobTopLogprob;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionTokenLogprobTopLogprob?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ChatCompletionTokenLogprobTopLogprob?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionTool.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionTool.g.cs
index 2c2cd18d..165330b5 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionTool.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionTool.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionTool?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ChatCompletionTool),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ChatCompletionTool;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionTool?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ChatCompletionTool?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionToolChoiceOption.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionToolChoiceOption.g.cs
index cc3968e5..fb9a433c 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionToolChoiceOption.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ChatCompletionToolChoiceOption.g.cs
@@ -273,5 +273,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionToolChoiceOption?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ChatCompletionToolChoiceOption),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ChatCompletionToolChoiceOption?;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ChatCompletionToolChoiceOption?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ChatCompletionToolChoiceOption?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ChunkingStrategyRequestParam.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ChunkingStrategyRequestParam.g.cs
index 4dd6714d..90bb59f3 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ChunkingStrategyRequestParam.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ChunkingStrategyRequestParam.g.cs
@@ -276,5 +276,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ChunkingStrategyRequestParam?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ChunkingStrategyRequestParam),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ChunkingStrategyRequestParam?;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ChunkingStrategyRequestParam?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ChunkingStrategyRequestParam?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ChunkingStrategyRequestParamDiscriminator.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ChunkingStrategyRequestParamDiscriminator.g.cs
index c9f5bc4b..87ceac11 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ChunkingStrategyRequestParamDiscriminator.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ChunkingStrategyRequestParamDiscriminator.g.cs
@@ -78,5 +78,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ChunkingStrategyRequestParamDiscriminator?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ChunkingStrategyRequestParamDiscriminator),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ChunkingStrategyRequestParamDiscriminator;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ChunkingStrategyRequestParamDiscriminator?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ChunkingStrategyRequestParamDiscriminator?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CompleteUploadRequest.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CompleteUploadRequest.g.cs
index 411324dd..829a22db 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CompleteUploadRequest.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CompleteUploadRequest.g.cs
@@ -84,5 +84,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CompleteUploadRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CompleteUploadRequest),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CompleteUploadRequest;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CompleteUploadRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CompleteUploadRequest?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CompletionUsage.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CompletionUsage.g.cs
index f9a065a2..f40f5c47 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CompletionUsage.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CompletionUsage.g.cs
@@ -104,5 +104,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CompletionUsage?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CompletionUsage),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CompletionUsage;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CompletionUsage?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CompletionUsage?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CompletionUsageCompletionTokensDetails.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CompletionUsageCompletionTokensDetails.g.cs
index 9c3b2c7b..cfdb7746 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CompletionUsageCompletionTokensDetails.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CompletionUsageCompletionTokensDetails.g.cs
@@ -100,5 +100,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CompletionUsageCompletionTokensDetails?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CompletionUsageCompletionTokensDetails),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CompletionUsageCompletionTokensDetails;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CompletionUsageCompletionTokensDetails?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CompletionUsageCompletionTokensDetails?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CompletionUsagePromptTokensDetails.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CompletionUsagePromptTokensDetails.g.cs
index 25a777c6..652974e7 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CompletionUsagePromptTokensDetails.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CompletionUsagePromptTokensDetails.g.cs
@@ -83,5 +83,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CompletionUsagePromptTokensDetails?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CompletionUsagePromptTokensDetails),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CompletionUsagePromptTokensDetails;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CompletionUsagePromptTokensDetails?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CompletionUsagePromptTokensDetails?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ContentItem.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ContentItem.g.cs
index 1b85af4d..0c89d4e6 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ContentItem.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ContentItem.g.cs
@@ -378,5 +378,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ContentItem?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ContentItem),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ContentItem?;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ContentItem?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ContentItem?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ContentItem2.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ContentItem2.g.cs
index 5ef22554..e3ce3e1d 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ContentItem2.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ContentItem2.g.cs
@@ -378,5 +378,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ContentItem2?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ContentItem2),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ContentItem2?;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ContentItem2?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ContentItem2?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ContentVariant2Item.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ContentVariant2Item.g.cs
index 1679082e..763762e5 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ContentVariant2Item.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ContentVariant2Item.g.cs
@@ -327,5 +327,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ContentVariant2Item?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ContentVariant2Item),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ContentVariant2Item?;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ContentVariant2Item?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ContentVariant2Item?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateAssistantRequest.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateAssistantRequest.g.cs
index d322e6bd..b525bda2 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateAssistantRequest.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateAssistantRequest.g.cs
@@ -145,5 +145,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateAssistantRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateAssistantRequest),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateAssistantRequest;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateAssistantRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateAssistantRequest?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateAssistantRequestMetadata.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateAssistantRequestMetadata.g.cs
index 23560f90..bbd03b53 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateAssistantRequestMetadata.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateAssistantRequestMetadata.g.cs
@@ -72,5 +72,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateAssistantRequestMetadata?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateAssistantRequestMetadata),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateAssistantRequestMetadata;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateAssistantRequestMetadata?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateAssistantRequestMetadata?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateAssistantRequestToolDiscriminator.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateAssistantRequestToolDiscriminator.g.cs
index 7491454a..e026d4f4 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateAssistantRequestToolDiscriminator.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateAssistantRequestToolDiscriminator.g.cs
@@ -78,5 +78,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateAssistantRequestToolDiscriminator?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateAssistantRequestToolDiscriminator),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateAssistantRequestToolDiscriminator;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateAssistantRequestToolDiscriminator?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateAssistantRequestToolDiscriminator?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateAssistantRequestToolResources.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateAssistantRequestToolResources.g.cs
index 96b319f5..5e94bafa 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateAssistantRequestToolResources.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateAssistantRequestToolResources.g.cs
@@ -83,5 +83,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateAssistantRequestToolResources?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateAssistantRequestToolResources),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateAssistantRequestToolResources;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateAssistantRequestToolResources?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateAssistantRequestToolResources?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateAssistantRequestToolResourcesCodeInterpreter.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateAssistantRequestToolResourcesCodeInterpreter.g.cs
index cdbca236..37378887 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateAssistantRequestToolResourcesCodeInterpreter.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateAssistantRequestToolResourcesCodeInterpreter.g.cs
@@ -77,5 +77,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateAssistantRequestToolResourcesCodeInterpreter?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateAssistantRequestToolResourcesCodeInterpreter),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateAssistantRequestToolResourcesCodeInterpreter;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateAssistantRequestToolResourcesCodeInterpreter?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateAssistantRequestToolResourcesCodeInterpreter?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateAssistantRequestToolResourcesFileSearch.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateAssistantRequestToolResourcesFileSearch.g.cs
index c6058bd8..6c35262d 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateAssistantRequestToolResourcesFileSearch.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateAssistantRequestToolResourcesFileSearch.g.cs
@@ -83,5 +83,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateAssistantRequestToolResourcesFileSearch?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateAssistantRequestToolResourcesFileSearch),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateAssistantRequestToolResourcesFileSearch;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateAssistantRequestToolResourcesFileSearch?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateAssistantRequestToolResourcesFileSearch?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateAssistantRequestToolResourcesFileSearchVariant1.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateAssistantRequestToolResourcesFileSearchVariant1.g.cs
index 41669ac6..a4d08d10 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateAssistantRequestToolResourcesFileSearchVariant1.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateAssistantRequestToolResourcesFileSearchVariant1.g.cs
@@ -72,5 +72,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateAssistantRequestToolResourcesFileSearchVariant1?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateAssistantRequestToolResourcesFileSearchVariant1),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateAssistantRequestToolResourcesFileSearchVariant1;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateAssistantRequestToolResourcesFileSearchVariant1?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateAssistantRequestToolResourcesFileSearchVariant1?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateAssistantRequestToolResourcesFileSearchVariant2.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateAssistantRequestToolResourcesFileSearchVariant2.g.cs
index 47a504cf..49ed17de 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateAssistantRequestToolResourcesFileSearchVariant2.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateAssistantRequestToolResourcesFileSearchVariant2.g.cs
@@ -72,5 +72,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateAssistantRequestToolResourcesFileSearchVariant2?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateAssistantRequestToolResourcesFileSearchVariant2),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateAssistantRequestToolResourcesFileSearchVariant2;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateAssistantRequestToolResourcesFileSearchVariant2?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateAssistantRequestToolResourcesFileSearchVariant2?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateAssistantRequestToolResourcesFileSearchVectorStore.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateAssistantRequestToolResourcesFileSearchVectorStore.g.cs
index 0997575a..b886d31a 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateAssistantRequestToolResourcesFileSearchVectorStore.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateAssistantRequestToolResourcesFileSearchVectorStore.g.cs
@@ -90,5 +90,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateAssistantRequestToolResourcesFileSearchVectorStore?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateAssistantRequestToolResourcesFileSearchVectorStore),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateAssistantRequestToolResourcesFileSearchVectorStore;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateAssistantRequestToolResourcesFileSearchVectorStore?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateAssistantRequestToolResourcesFileSearchVectorStore?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateAssistantRequestToolResourcesFileSearchVectorStoreChunkingStrategy.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateAssistantRequestToolResourcesFileSearchVectorStoreChunkingStrategy.g.cs
index df379b22..302b40c3 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateAssistantRequestToolResourcesFileSearchVectorStoreChunkingStrategy.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateAssistantRequestToolResourcesFileSearchVectorStoreChunkingStrategy.g.cs
@@ -276,5 +276,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateAssistantRequestToolResourcesFileSearchVectorStoreChunkingStrategy?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateAssistantRequestToolResourcesFileSearchVectorStoreChunkingStrategy),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateAssistantRequestToolResourcesFileSearchVectorStoreChunkingStrategy?;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateAssistantRequestToolResourcesFileSearchVectorStoreChunkingStrategy?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateAssistantRequestToolResourcesFileSearchVectorStoreChunkingStrategy?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateAssistantRequestToolResourcesFileSearchVectorStoreChunkingStrategyDiscriminator.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateAssistantRequestToolResourcesFileSearchVectorStoreChunkingStrategyDiscriminator.g.cs
index 193be5d5..6a2c25bd 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateAssistantRequestToolResourcesFileSearchVectorStoreChunkingStrategyDiscriminator.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateAssistantRequestToolResourcesFileSearchVectorStoreChunkingStrategyDiscriminator.g.cs
@@ -78,5 +78,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateAssistantRequestToolResourcesFileSearchVectorStoreChunkingStrategyDiscriminator?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateAssistantRequestToolResourcesFileSearchVectorStoreChunkingStrategyDiscriminator),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateAssistantRequestToolResourcesFileSearchVectorStoreChunkingStrategyDiscriminator;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateAssistantRequestToolResourcesFileSearchVectorStoreChunkingStrategyDiscriminator?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateAssistantRequestToolResourcesFileSearchVectorStoreChunkingStrategyDiscriminator?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateAssistantRequestToolResourcesFileSearchVectorStoreChunkingStrategyVariant1.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateAssistantRequestToolResourcesFileSearchVectorStoreChunkingStrategyVariant1.g.cs
index cd32f600..dea04e32 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateAssistantRequestToolResourcesFileSearchVectorStoreChunkingStrategyVariant1.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateAssistantRequestToolResourcesFileSearchVectorStoreChunkingStrategyVariant1.g.cs
@@ -78,5 +78,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateAssistantRequestToolResourcesFileSearchVectorStoreChunkingStrategyVariant1?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateAssistantRequestToolResourcesFileSearchVectorStoreChunkingStrategyVariant1),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateAssistantRequestToolResourcesFileSearchVectorStoreChunkingStrategyVariant1;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateAssistantRequestToolResourcesFileSearchVectorStoreChunkingStrategyVariant1?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateAssistantRequestToolResourcesFileSearchVectorStoreChunkingStrategyVariant1?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateAssistantRequestToolResourcesFileSearchVectorStoreChunkingStrategyVariant2.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateAssistantRequestToolResourcesFileSearchVectorStoreChunkingStrategyVariant2.g.cs
index 461f086c..35de59b8 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateAssistantRequestToolResourcesFileSearchVectorStoreChunkingStrategyVariant2.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateAssistantRequestToolResourcesFileSearchVectorStoreChunkingStrategyVariant2.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateAssistantRequestToolResourcesFileSearchVectorStoreChunkingStrategyVariant2?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateAssistantRequestToolResourcesFileSearchVectorStoreChunkingStrategyVariant2),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateAssistantRequestToolResourcesFileSearchVectorStoreChunkingStrategyVariant2;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateAssistantRequestToolResourcesFileSearchVectorStoreChunkingStrategyVariant2?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateAssistantRequestToolResourcesFileSearchVectorStoreChunkingStrategyVariant2?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateAssistantRequestToolResourcesFileSearchVectorStoreChunkingStrategyVariant2Static.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateAssistantRequestToolResourcesFileSearchVectorStoreChunkingStrategyVariant2Static.g.cs
index 0937f050..bd7b7f85 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateAssistantRequestToolResourcesFileSearchVectorStoreChunkingStrategyVariant2Static.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateAssistantRequestToolResourcesFileSearchVectorStoreChunkingStrategyVariant2Static.g.cs
@@ -86,5 +86,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateAssistantRequestToolResourcesFileSearchVectorStoreChunkingStrategyVariant2Static?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateAssistantRequestToolResourcesFileSearchVectorStoreChunkingStrategyVariant2Static),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateAssistantRequestToolResourcesFileSearchVectorStoreChunkingStrategyVariant2Static;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateAssistantRequestToolResourcesFileSearchVectorStoreChunkingStrategyVariant2Static?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateAssistantRequestToolResourcesFileSearchVectorStoreChunkingStrategyVariant2Static?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateAssistantRequestToolResourcesFileSearchVectorStoreMetadata.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateAssistantRequestToolResourcesFileSearchVectorStoreMetadata.g.cs
index 3c9ba57a..7dc87110 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateAssistantRequestToolResourcesFileSearchVectorStoreMetadata.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateAssistantRequestToolResourcesFileSearchVectorStoreMetadata.g.cs
@@ -72,5 +72,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateAssistantRequestToolResourcesFileSearchVectorStoreMetadata?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateAssistantRequestToolResourcesFileSearchVectorStoreMetadata),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateAssistantRequestToolResourcesFileSearchVectorStoreMetadata;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateAssistantRequestToolResourcesFileSearchVectorStoreMetadata?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateAssistantRequestToolResourcesFileSearchVectorStoreMetadata?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateBatchRequest.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateBatchRequest.g.cs
index 27317b00..cd7262ed 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateBatchRequest.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateBatchRequest.g.cs
@@ -101,5 +101,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateBatchRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateBatchRequest),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateBatchRequest;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateBatchRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateBatchRequest?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateBatchRequestMetadata.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateBatchRequestMetadata.g.cs
index 2c1b9b06..6a004480 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateBatchRequestMetadata.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateBatchRequestMetadata.g.cs
@@ -72,5 +72,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateBatchRequestMetadata?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateBatchRequestMetadata),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateBatchRequestMetadata;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateBatchRequestMetadata?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateBatchRequestMetadata?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateChatCompletionFunctionResponse.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateChatCompletionFunctionResponse.g.cs
index a324e1a5..cb509c09 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateChatCompletionFunctionResponse.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateChatCompletionFunctionResponse.g.cs
@@ -120,5 +120,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateChatCompletionFunctionResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateChatCompletionFunctionResponse),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateChatCompletionFunctionResponse;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateChatCompletionFunctionResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateChatCompletionFunctionResponse?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateChatCompletionFunctionResponseChoice.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateChatCompletionFunctionResponseChoice.g.cs
index ecad78a5..087cc66f 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateChatCompletionFunctionResponseChoice.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateChatCompletionFunctionResponseChoice.g.cs
@@ -93,5 +93,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateChatCompletionFunctionResponseChoice?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateChatCompletionFunctionResponseChoice),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateChatCompletionFunctionResponseChoice;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateChatCompletionFunctionResponseChoice?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateChatCompletionFunctionResponseChoice?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateChatCompletionImageResponse.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateChatCompletionImageResponse.g.cs
index 0b36f52f..2a2cc664 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateChatCompletionImageResponse.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateChatCompletionImageResponse.g.cs
@@ -72,5 +72,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateChatCompletionImageResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateChatCompletionImageResponse),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateChatCompletionImageResponse;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateChatCompletionImageResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateChatCompletionImageResponse?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateChatCompletionRequest.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateChatCompletionRequest.g.cs
index a2fc09b5..639f5764 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateChatCompletionRequest.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateChatCompletionRequest.g.cs
@@ -313,5 +313,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateChatCompletionRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateChatCompletionRequest),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateChatCompletionRequest;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateChatCompletionRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateChatCompletionRequest?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateChatCompletionRequestAudio.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateChatCompletionRequestAudio.g.cs
index 094e29b1..4ddc96fa 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateChatCompletionRequestAudio.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateChatCompletionRequestAudio.g.cs
@@ -90,5 +90,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateChatCompletionRequestAudio?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateChatCompletionRequestAudio),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateChatCompletionRequestAudio;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateChatCompletionRequestAudio?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateChatCompletionRequestAudio?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateChatCompletionRequestLogitBias.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateChatCompletionRequestLogitBias.g.cs
index bef56ce7..5b2403c3 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateChatCompletionRequestLogitBias.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateChatCompletionRequestLogitBias.g.cs
@@ -73,5 +73,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateChatCompletionRequestLogitBias?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateChatCompletionRequestLogitBias),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateChatCompletionRequestLogitBias;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateChatCompletionRequestLogitBias?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateChatCompletionRequestLogitBias?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateChatCompletionRequestMetadata.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateChatCompletionRequestMetadata.g.cs
index 7b97b2ef..f2063380 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateChatCompletionRequestMetadata.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateChatCompletionRequestMetadata.g.cs
@@ -73,5 +73,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateChatCompletionRequestMetadata?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateChatCompletionRequestMetadata),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateChatCompletionRequestMetadata;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateChatCompletionRequestMetadata?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateChatCompletionRequestMetadata?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateChatCompletionRequestResponseFormatDiscriminator.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateChatCompletionRequestResponseFormatDiscriminator.g.cs
index e2e5c634..524e65c5 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateChatCompletionRequestResponseFormatDiscriminator.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateChatCompletionRequestResponseFormatDiscriminator.g.cs
@@ -78,5 +78,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateChatCompletionRequestResponseFormatDiscriminator?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateChatCompletionRequestResponseFormatDiscriminator),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateChatCompletionRequestResponseFormatDiscriminator;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateChatCompletionRequestResponseFormatDiscriminator?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateChatCompletionRequestResponseFormatDiscriminator?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateChatCompletionResponse.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateChatCompletionResponse.g.cs
index 82e8dab9..0843bee0 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateChatCompletionResponse.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateChatCompletionResponse.g.cs
@@ -128,5 +128,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateChatCompletionResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateChatCompletionResponse),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateChatCompletionResponse;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateChatCompletionResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateChatCompletionResponse?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateChatCompletionResponseChoice.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateChatCompletionResponseChoice.g.cs
index d9fa901c..b78497b0 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateChatCompletionResponseChoice.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateChatCompletionResponseChoice.g.cs
@@ -102,5 +102,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateChatCompletionResponseChoice?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateChatCompletionResponseChoice),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateChatCompletionResponseChoice;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateChatCompletionResponseChoice?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateChatCompletionResponseChoice?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateChatCompletionResponseChoiceLogprobs.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateChatCompletionResponseChoiceLogprobs.g.cs
index e53e236a..73997295 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateChatCompletionResponseChoiceLogprobs.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateChatCompletionResponseChoiceLogprobs.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateChatCompletionResponseChoiceLogprobs?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateChatCompletionResponseChoiceLogprobs),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateChatCompletionResponseChoiceLogprobs;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateChatCompletionResponseChoiceLogprobs?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateChatCompletionResponseChoiceLogprobs?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateChatCompletionStreamResponse.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateChatCompletionStreamResponse.g.cs
index 1446a2d4..58d6a418 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateChatCompletionStreamResponse.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateChatCompletionStreamResponse.g.cs
@@ -130,5 +130,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateChatCompletionStreamResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateChatCompletionStreamResponse),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateChatCompletionStreamResponse;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateChatCompletionStreamResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateChatCompletionStreamResponse?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateChatCompletionStreamResponseChoice.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateChatCompletionStreamResponseChoice.g.cs
index 26e3a76b..e8b89b1f 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateChatCompletionStreamResponseChoice.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateChatCompletionStreamResponseChoice.g.cs
@@ -102,5 +102,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateChatCompletionStreamResponseChoice?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateChatCompletionStreamResponseChoice),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateChatCompletionStreamResponseChoice;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateChatCompletionStreamResponseChoice?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateChatCompletionStreamResponseChoice?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateChatCompletionStreamResponseChoiceLogprobs.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateChatCompletionStreamResponseChoiceLogprobs.g.cs
index 279b1220..72b3af87 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateChatCompletionStreamResponseChoiceLogprobs.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateChatCompletionStreamResponseChoiceLogprobs.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateChatCompletionStreamResponseChoiceLogprobs?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateChatCompletionStreamResponseChoiceLogprobs),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateChatCompletionStreamResponseChoiceLogprobs;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateChatCompletionStreamResponseChoiceLogprobs?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateChatCompletionStreamResponseChoiceLogprobs?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateChatCompletionStreamResponseUsage.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateChatCompletionStreamResponseUsage.g.cs
index e755f2dd..8b5522eb 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateChatCompletionStreamResponseUsage.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateChatCompletionStreamResponseUsage.g.cs
@@ -93,5 +93,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateChatCompletionStreamResponseUsage?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateChatCompletionStreamResponseUsage),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateChatCompletionStreamResponseUsage;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateChatCompletionStreamResponseUsage?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateChatCompletionStreamResponseUsage?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateCompletionRequest.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateCompletionRequest.g.cs
index 8864b3a3..58994bc7 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateCompletionRequest.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateCompletionRequest.g.cs
@@ -216,5 +216,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateCompletionRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateCompletionRequest),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateCompletionRequest;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateCompletionRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateCompletionRequest?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateCompletionRequestLogitBias.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateCompletionRequestLogitBias.g.cs
index 6607a079..508afbdb 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateCompletionRequestLogitBias.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateCompletionRequestLogitBias.g.cs
@@ -74,5 +74,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateCompletionRequestLogitBias?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateCompletionRequestLogitBias),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateCompletionRequestLogitBias;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateCompletionRequestLogitBias?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateCompletionRequestLogitBias?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateCompletionResponse.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateCompletionResponse.g.cs
index ee9d67c9..2bf3fa96 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateCompletionResponse.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateCompletionResponse.g.cs
@@ -120,5 +120,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateCompletionResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateCompletionResponse),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateCompletionResponse;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateCompletionResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateCompletionResponse?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateCompletionResponseChoice.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateCompletionResponseChoice.g.cs
index 9ea5ba15..194d5b07 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateCompletionResponseChoice.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateCompletionResponseChoice.g.cs
@@ -102,5 +102,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateCompletionResponseChoice?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateCompletionResponseChoice),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateCompletionResponseChoice;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateCompletionResponseChoice?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateCompletionResponseChoice?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateCompletionResponseChoiceLogprobs.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateCompletionResponseChoiceLogprobs.g.cs
index 3614b2c6..ce9aeb99 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateCompletionResponseChoiceLogprobs.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateCompletionResponseChoiceLogprobs.g.cs
@@ -95,5 +95,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateCompletionResponseChoiceLogprobs?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateCompletionResponseChoiceLogprobs),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateCompletionResponseChoiceLogprobs;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateCompletionResponseChoiceLogprobs?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateCompletionResponseChoiceLogprobs?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateCompletionResponseChoiceLogprobsTopLogprob.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateCompletionResponseChoiceLogprobsTopLogprob.g.cs
index 724d08b3..53c8dc05 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateCompletionResponseChoiceLogprobsTopLogprob.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateCompletionResponseChoiceLogprobsTopLogprob.g.cs
@@ -72,5 +72,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateCompletionResponseChoiceLogprobsTopLogprob?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateCompletionResponseChoiceLogprobsTopLogprob),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateCompletionResponseChoiceLogprobsTopLogprob;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateCompletionResponseChoiceLogprobsTopLogprob?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateCompletionResponseChoiceLogprobsTopLogprob?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateEmbeddingRequest.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateEmbeddingRequest.g.cs
index e821ca71..cfa71e56 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateEmbeddingRequest.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateEmbeddingRequest.g.cs
@@ -113,5 +113,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateEmbeddingRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateEmbeddingRequest),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateEmbeddingRequest;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateEmbeddingRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateEmbeddingRequest?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateEmbeddingResponse.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateEmbeddingResponse.g.cs
index e183e51f..4460db2e 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateEmbeddingResponse.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateEmbeddingResponse.g.cs
@@ -99,5 +99,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateEmbeddingResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateEmbeddingResponse),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateEmbeddingResponse;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateEmbeddingResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateEmbeddingResponse?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateEmbeddingResponseUsage.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateEmbeddingResponseUsage.g.cs
index 3c17a95d..f7c964b9 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateEmbeddingResponseUsage.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateEmbeddingResponseUsage.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateEmbeddingResponseUsage?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateEmbeddingResponseUsage),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateEmbeddingResponseUsage;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateEmbeddingResponseUsage?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateEmbeddingResponseUsage?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateFileRequest.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateFileRequest.g.cs
index 061f38bb..7eb0e321 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateFileRequest.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateFileRequest.g.cs
@@ -94,5 +94,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateFileRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateFileRequest),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateFileRequest;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateFileRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateFileRequest?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateFineTuningJobRequest.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateFineTuningJobRequest.g.cs
index 7b524dad..53e2b497 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateFineTuningJobRequest.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateFineTuningJobRequest.g.cs
@@ -135,5 +135,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateFineTuningJobRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateFineTuningJobRequest),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateFineTuningJobRequest;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateFineTuningJobRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateFineTuningJobRequest?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateFineTuningJobRequestHyperparameters.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateFineTuningJobRequestHyperparameters.g.cs
index 2495328d..73691903 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateFineTuningJobRequestHyperparameters.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateFineTuningJobRequestHyperparameters.g.cs
@@ -100,5 +100,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateFineTuningJobRequestHyperparameters?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateFineTuningJobRequestHyperparameters),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateFineTuningJobRequestHyperparameters;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateFineTuningJobRequestHyperparameters?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateFineTuningJobRequestHyperparameters?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateFineTuningJobRequestIntegration.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateFineTuningJobRequestIntegration.g.cs
index d0247c15..515f2489 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateFineTuningJobRequestIntegration.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateFineTuningJobRequestIntegration.g.cs
@@ -87,5 +87,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateFineTuningJobRequestIntegration?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateFineTuningJobRequestIntegration),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateFineTuningJobRequestIntegration;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateFineTuningJobRequestIntegration?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateFineTuningJobRequestIntegration?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateFineTuningJobRequestIntegrationWandb.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateFineTuningJobRequestIntegrationWandb.g.cs
index 68ebdad9..01b711dc 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateFineTuningJobRequestIntegrationWandb.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateFineTuningJobRequestIntegrationWandb.g.cs
@@ -101,5 +101,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateFineTuningJobRequestIntegrationWandb?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateFineTuningJobRequestIntegrationWandb),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateFineTuningJobRequestIntegrationWandb;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateFineTuningJobRequestIntegrationWandb?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateFineTuningJobRequestIntegrationWandb?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateImageEditRequest.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateImageEditRequest.g.cs
index 764549fd..3bb9697d 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateImageEditRequest.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateImageEditRequest.g.cs
@@ -149,5 +149,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateImageEditRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateImageEditRequest),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateImageEditRequest;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateImageEditRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateImageEditRequest?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateImageRequest.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateImageRequest.g.cs
index 3f09a2e1..a46fe84e 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateImageRequest.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateImageRequest.g.cs
@@ -141,5 +141,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateImageRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateImageRequest),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateImageRequest;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateImageRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateImageRequest?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateImageVariationRequest.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateImageVariationRequest.g.cs
index 22f050e4..afe3e16c 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateImageVariationRequest.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateImageVariationRequest.g.cs
@@ -129,5 +129,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateImageVariationRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateImageVariationRequest),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateImageVariationRequest;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateImageVariationRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateImageVariationRequest?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateMessageRequest.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateMessageRequest.g.cs
index 498ced93..fefe91dd 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateMessageRequest.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateMessageRequest.g.cs
@@ -103,5 +103,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateMessageRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateMessageRequest),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateMessageRequest;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateMessageRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateMessageRequest?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateMessageRequestAttachment.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateMessageRequestAttachment.g.cs
index 64540029..4e7484ca 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateMessageRequestAttachment.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateMessageRequestAttachment.g.cs
@@ -83,5 +83,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateMessageRequestAttachment?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateMessageRequestAttachment),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateMessageRequestAttachment;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateMessageRequestAttachment?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateMessageRequestAttachment?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateMessageRequestAttachmentToolDiscriminator.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateMessageRequestAttachmentToolDiscriminator.g.cs
index 6da94758..c03b6efc 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateMessageRequestAttachmentToolDiscriminator.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateMessageRequestAttachmentToolDiscriminator.g.cs
@@ -78,5 +78,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateMessageRequestAttachmentToolDiscriminator?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateMessageRequestAttachmentToolDiscriminator),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateMessageRequestAttachmentToolDiscriminator;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateMessageRequestAttachmentToolDiscriminator?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateMessageRequestAttachmentToolDiscriminator?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateMessageRequestContentVariant2ItemDiscriminator.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateMessageRequestContentVariant2ItemDiscriminator.g.cs
index 3808cfd9..99e85e69 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateMessageRequestContentVariant2ItemDiscriminator.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateMessageRequestContentVariant2ItemDiscriminator.g.cs
@@ -78,5 +78,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateMessageRequestContentVariant2ItemDiscriminator?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateMessageRequestContentVariant2ItemDiscriminator),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateMessageRequestContentVariant2ItemDiscriminator;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateMessageRequestContentVariant2ItemDiscriminator?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateMessageRequestContentVariant2ItemDiscriminator?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateMessageRequestMetadata.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateMessageRequestMetadata.g.cs
index d67b8f30..1749f5cc 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateMessageRequestMetadata.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateMessageRequestMetadata.g.cs
@@ -72,5 +72,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateMessageRequestMetadata?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateMessageRequestMetadata),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateMessageRequestMetadata;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateMessageRequestMetadata?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateMessageRequestMetadata?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateModerationRequest.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateModerationRequest.g.cs
index 290fc9a4..5e0325f3 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateModerationRequest.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateModerationRequest.g.cs
@@ -93,5 +93,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateModerationRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateModerationRequest),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateModerationRequest;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateModerationRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateModerationRequest?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateModerationRequestInputVariant3ItemDiscriminator.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateModerationRequestInputVariant3ItemDiscriminator.g.cs
index f4371721..c33f9ba7 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateModerationRequestInputVariant3ItemDiscriminator.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateModerationRequestInputVariant3ItemDiscriminator.g.cs
@@ -78,5 +78,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateModerationRequestInputVariant3ItemDiscriminator?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateModerationRequestInputVariant3ItemDiscriminator),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateModerationRequestInputVariant3ItemDiscriminator;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateModerationRequestInputVariant3ItemDiscriminator?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateModerationRequestInputVariant3ItemDiscriminator?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateModerationRequestInputVariant3ItemVariant1.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateModerationRequestInputVariant3ItemVariant1.g.cs
index 47452f09..4448202c 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateModerationRequestInputVariant3ItemVariant1.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateModerationRequestInputVariant3ItemVariant1.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateModerationRequestInputVariant3ItemVariant1?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateModerationRequestInputVariant3ItemVariant1),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateModerationRequestInputVariant3ItemVariant1;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateModerationRequestInputVariant3ItemVariant1?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateModerationRequestInputVariant3ItemVariant1?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateModerationRequestInputVariant3ItemVariant1ImageUrl.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateModerationRequestInputVariant3ItemVariant1ImageUrl.g.cs
index 2ed4daa9..2fea13a9 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateModerationRequestInputVariant3ItemVariant1ImageUrl.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateModerationRequestInputVariant3ItemVariant1ImageUrl.g.cs
@@ -79,5 +79,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateModerationRequestInputVariant3ItemVariant1ImageUrl?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateModerationRequestInputVariant3ItemVariant1ImageUrl),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateModerationRequestInputVariant3ItemVariant1ImageUrl;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateModerationRequestInputVariant3ItemVariant1ImageUrl?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateModerationRequestInputVariant3ItemVariant1ImageUrl?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateModerationRequestInputVariant3ItemVariant2.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateModerationRequestInputVariant3ItemVariant2.g.cs
index d15f6cc0..7201df2e 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateModerationRequestInputVariant3ItemVariant2.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateModerationRequestInputVariant3ItemVariant2.g.cs
@@ -86,5 +86,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateModerationRequestInputVariant3ItemVariant2?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateModerationRequestInputVariant3ItemVariant2),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateModerationRequestInputVariant3ItemVariant2;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateModerationRequestInputVariant3ItemVariant2?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateModerationRequestInputVariant3ItemVariant2?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateModerationResponse.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateModerationResponse.g.cs
index 6b02e5e7..5f008ccb 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateModerationResponse.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateModerationResponse.g.cs
@@ -92,5 +92,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateModerationResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateModerationResponse),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateModerationResponse;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateModerationResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateModerationResponse?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateModerationResponseResult.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateModerationResponseResult.g.cs
index 9de60818..52ab6dc2 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateModerationResponseResult.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateModerationResponseResult.g.cs
@@ -99,5 +99,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateModerationResponseResult?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateModerationResponseResult),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateModerationResponseResult;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateModerationResponseResult?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateModerationResponseResult?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateModerationResponseResultCategories.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateModerationResponseResultCategories.g.cs
index f03e5ff8..9aab4552 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateModerationResponseResultCategories.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateModerationResponseResultCategories.g.cs
@@ -162,5 +162,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateModerationResponseResultCategories?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateModerationResponseResultCategories),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateModerationResponseResultCategories;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateModerationResponseResultCategories?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateModerationResponseResultCategories?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateModerationResponseResultCategoryAppliedInputTypes.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateModerationResponseResultCategoryAppliedInputTypes.g.cs
index ef2d7f7d..eae4a752 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateModerationResponseResultCategoryAppliedInputTypes.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateModerationResponseResultCategoryAppliedInputTypes.g.cs
@@ -162,5 +162,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateModerationResponseResultCategoryAppliedInputTypes?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateModerationResponseResultCategoryAppliedInputTypes),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateModerationResponseResultCategoryAppliedInputTypes;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateModerationResponseResultCategoryAppliedInputTypes?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateModerationResponseResultCategoryAppliedInputTypes?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateModerationResponseResultCategoryScores.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateModerationResponseResultCategoryScores.g.cs
index 471d941c..3986de1e 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateModerationResponseResultCategoryScores.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateModerationResponseResultCategoryScores.g.cs
@@ -162,5 +162,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateModerationResponseResultCategoryScores?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateModerationResponseResultCategoryScores),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateModerationResponseResultCategoryScores;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateModerationResponseResultCategoryScores?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateModerationResponseResultCategoryScores?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateRunRequest.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateRunRequest.g.cs
index 33223612..0ef154c5 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateRunRequest.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateRunRequest.g.cs
@@ -186,5 +186,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateRunRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateRunRequest),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateRunRequest;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateRunRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateRunRequest?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateRunRequestMetadata.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateRunRequestMetadata.g.cs
index f923608b..89efb419 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateRunRequestMetadata.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateRunRequestMetadata.g.cs
@@ -72,5 +72,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateRunRequestMetadata?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateRunRequestMetadata),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateRunRequestMetadata;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateRunRequestMetadata?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateRunRequestMetadata?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateRunRequestToolDiscriminator.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateRunRequestToolDiscriminator.g.cs
index 09eb3c7a..e428de68 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateRunRequestToolDiscriminator.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateRunRequestToolDiscriminator.g.cs
@@ -78,5 +78,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateRunRequestToolDiscriminator?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateRunRequestToolDiscriminator),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateRunRequestToolDiscriminator;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateRunRequestToolDiscriminator?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateRunRequestToolDiscriminator?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateSpeechRequest.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateSpeechRequest.g.cs
index 25fae730..b5a08d92 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateSpeechRequest.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateSpeechRequest.g.cs
@@ -111,5 +111,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateSpeechRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateSpeechRequest),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateSpeechRequest;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateSpeechRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateSpeechRequest?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadAndRunRequest.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadAndRunRequest.g.cs
index 4075b7ca..4f2f7c36 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadAndRunRequest.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadAndRunRequest.g.cs
@@ -186,5 +186,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateThreadAndRunRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateThreadAndRunRequest),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateThreadAndRunRequest;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateThreadAndRunRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateThreadAndRunRequest?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadAndRunRequestMetadata.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadAndRunRequestMetadata.g.cs
index 76c7cbd3..7cdd096e 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadAndRunRequestMetadata.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadAndRunRequestMetadata.g.cs
@@ -72,5 +72,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateThreadAndRunRequestMetadata?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateThreadAndRunRequestMetadata),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateThreadAndRunRequestMetadata;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateThreadAndRunRequestMetadata?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateThreadAndRunRequestMetadata?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadAndRunRequestToolDiscriminator.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadAndRunRequestToolDiscriminator.g.cs
index 8e1609e0..0aefc171 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadAndRunRequestToolDiscriminator.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadAndRunRequestToolDiscriminator.g.cs
@@ -78,5 +78,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateThreadAndRunRequestToolDiscriminator?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateThreadAndRunRequestToolDiscriminator),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateThreadAndRunRequestToolDiscriminator;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateThreadAndRunRequestToolDiscriminator?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateThreadAndRunRequestToolDiscriminator?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadAndRunRequestToolResources.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadAndRunRequestToolResources.g.cs
index 45e4a078..6b01edd7 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadAndRunRequestToolResources.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadAndRunRequestToolResources.g.cs
@@ -83,5 +83,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateThreadAndRunRequestToolResources?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateThreadAndRunRequestToolResources),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateThreadAndRunRequestToolResources;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateThreadAndRunRequestToolResources?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateThreadAndRunRequestToolResources?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadAndRunRequestToolResourcesCodeInterpreter.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadAndRunRequestToolResourcesCodeInterpreter.g.cs
index 9c0e1798..3f453bd0 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadAndRunRequestToolResourcesCodeInterpreter.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadAndRunRequestToolResourcesCodeInterpreter.g.cs
@@ -77,5 +77,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateThreadAndRunRequestToolResourcesCodeInterpreter?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateThreadAndRunRequestToolResourcesCodeInterpreter),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateThreadAndRunRequestToolResourcesCodeInterpreter;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateThreadAndRunRequestToolResourcesCodeInterpreter?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateThreadAndRunRequestToolResourcesCodeInterpreter?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadAndRunRequestToolResourcesFileSearch.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadAndRunRequestToolResourcesFileSearch.g.cs
index 6d482642..5d13324e 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadAndRunRequestToolResourcesFileSearch.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadAndRunRequestToolResourcesFileSearch.g.cs
@@ -77,5 +77,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateThreadAndRunRequestToolResourcesFileSearch?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateThreadAndRunRequestToolResourcesFileSearch),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateThreadAndRunRequestToolResourcesFileSearch;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateThreadAndRunRequestToolResourcesFileSearch?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateThreadAndRunRequestToolResourcesFileSearch?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadRequest.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadRequest.g.cs
index 88fe1b9f..5024a9c3 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadRequest.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadRequest.g.cs
@@ -89,5 +89,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateThreadRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateThreadRequest),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateThreadRequest;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateThreadRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateThreadRequest?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadRequestMetadata.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadRequestMetadata.g.cs
index ea797f29..42ac5047 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadRequestMetadata.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadRequestMetadata.g.cs
@@ -72,5 +72,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateThreadRequestMetadata?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateThreadRequestMetadata),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateThreadRequestMetadata;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateThreadRequestMetadata?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateThreadRequestMetadata?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadRequestToolResources.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadRequestToolResources.g.cs
index 7d7d5729..d2b15b56 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadRequestToolResources.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadRequestToolResources.g.cs
@@ -83,5 +83,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateThreadRequestToolResources?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateThreadRequestToolResources),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateThreadRequestToolResources;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateThreadRequestToolResources?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateThreadRequestToolResources?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadRequestToolResourcesCodeInterpreter.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadRequestToolResourcesCodeInterpreter.g.cs
index 8a9636b8..d456d17c 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadRequestToolResourcesCodeInterpreter.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadRequestToolResourcesCodeInterpreter.g.cs
@@ -77,5 +77,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateThreadRequestToolResourcesCodeInterpreter?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateThreadRequestToolResourcesCodeInterpreter),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateThreadRequestToolResourcesCodeInterpreter;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateThreadRequestToolResourcesCodeInterpreter?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateThreadRequestToolResourcesCodeInterpreter?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadRequestToolResourcesFileSearch.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadRequestToolResourcesFileSearch.g.cs
index 1fb0af4d..bc2c3b73 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadRequestToolResourcesFileSearch.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadRequestToolResourcesFileSearch.g.cs
@@ -83,5 +83,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateThreadRequestToolResourcesFileSearch?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateThreadRequestToolResourcesFileSearch),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateThreadRequestToolResourcesFileSearch;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateThreadRequestToolResourcesFileSearch?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateThreadRequestToolResourcesFileSearch?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadRequestToolResourcesFileSearchVariant1.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadRequestToolResourcesFileSearchVariant1.g.cs
index 7eea1dd9..6c905c56 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadRequestToolResourcesFileSearchVariant1.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadRequestToolResourcesFileSearchVariant1.g.cs
@@ -72,5 +72,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateThreadRequestToolResourcesFileSearchVariant1?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateThreadRequestToolResourcesFileSearchVariant1),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateThreadRequestToolResourcesFileSearchVariant1;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateThreadRequestToolResourcesFileSearchVariant1?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateThreadRequestToolResourcesFileSearchVariant1?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadRequestToolResourcesFileSearchVariant2.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadRequestToolResourcesFileSearchVariant2.g.cs
index 1e769f9d..87eaf27d 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadRequestToolResourcesFileSearchVariant2.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadRequestToolResourcesFileSearchVariant2.g.cs
@@ -72,5 +72,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateThreadRequestToolResourcesFileSearchVariant2?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateThreadRequestToolResourcesFileSearchVariant2),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateThreadRequestToolResourcesFileSearchVariant2;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateThreadRequestToolResourcesFileSearchVariant2?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateThreadRequestToolResourcesFileSearchVariant2?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadRequestToolResourcesFileSearchVectorStore.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadRequestToolResourcesFileSearchVectorStore.g.cs
index ba4305af..8e04e9f0 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadRequestToolResourcesFileSearchVectorStore.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadRequestToolResourcesFileSearchVectorStore.g.cs
@@ -90,5 +90,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateThreadRequestToolResourcesFileSearchVectorStore?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateThreadRequestToolResourcesFileSearchVectorStore),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateThreadRequestToolResourcesFileSearchVectorStore;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateThreadRequestToolResourcesFileSearchVectorStore?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateThreadRequestToolResourcesFileSearchVectorStore?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadRequestToolResourcesFileSearchVectorStoreChunkingStrategy.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadRequestToolResourcesFileSearchVectorStoreChunkingStrategy.g.cs
index a0369a2c..8a1c6972 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadRequestToolResourcesFileSearchVectorStoreChunkingStrategy.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadRequestToolResourcesFileSearchVectorStoreChunkingStrategy.g.cs
@@ -276,5 +276,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateThreadRequestToolResourcesFileSearchVectorStoreChunkingStrategy?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateThreadRequestToolResourcesFileSearchVectorStoreChunkingStrategy),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateThreadRequestToolResourcesFileSearchVectorStoreChunkingStrategy?;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateThreadRequestToolResourcesFileSearchVectorStoreChunkingStrategy?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateThreadRequestToolResourcesFileSearchVectorStoreChunkingStrategy?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadRequestToolResourcesFileSearchVectorStoreChunkingStrategyDiscriminator.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadRequestToolResourcesFileSearchVectorStoreChunkingStrategyDiscriminator.g.cs
index 9d8f427d..584c7566 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadRequestToolResourcesFileSearchVectorStoreChunkingStrategyDiscriminator.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadRequestToolResourcesFileSearchVectorStoreChunkingStrategyDiscriminator.g.cs
@@ -78,5 +78,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateThreadRequestToolResourcesFileSearchVectorStoreChunkingStrategyDiscriminator?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateThreadRequestToolResourcesFileSearchVectorStoreChunkingStrategyDiscriminator),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateThreadRequestToolResourcesFileSearchVectorStoreChunkingStrategyDiscriminator;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateThreadRequestToolResourcesFileSearchVectorStoreChunkingStrategyDiscriminator?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateThreadRequestToolResourcesFileSearchVectorStoreChunkingStrategyDiscriminator?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadRequestToolResourcesFileSearchVectorStoreChunkingStrategyVariant1.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadRequestToolResourcesFileSearchVectorStoreChunkingStrategyVariant1.g.cs
index e0b20e84..8439283f 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadRequestToolResourcesFileSearchVectorStoreChunkingStrategyVariant1.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadRequestToolResourcesFileSearchVectorStoreChunkingStrategyVariant1.g.cs
@@ -78,5 +78,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateThreadRequestToolResourcesFileSearchVectorStoreChunkingStrategyVariant1?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateThreadRequestToolResourcesFileSearchVectorStoreChunkingStrategyVariant1),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateThreadRequestToolResourcesFileSearchVectorStoreChunkingStrategyVariant1;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateThreadRequestToolResourcesFileSearchVectorStoreChunkingStrategyVariant1?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateThreadRequestToolResourcesFileSearchVectorStoreChunkingStrategyVariant1?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadRequestToolResourcesFileSearchVectorStoreChunkingStrategyVariant2.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadRequestToolResourcesFileSearchVectorStoreChunkingStrategyVariant2.g.cs
index 5bb840f9..2d73d96f 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadRequestToolResourcesFileSearchVectorStoreChunkingStrategyVariant2.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadRequestToolResourcesFileSearchVectorStoreChunkingStrategyVariant2.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateThreadRequestToolResourcesFileSearchVectorStoreChunkingStrategyVariant2?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateThreadRequestToolResourcesFileSearchVectorStoreChunkingStrategyVariant2),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateThreadRequestToolResourcesFileSearchVectorStoreChunkingStrategyVariant2;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateThreadRequestToolResourcesFileSearchVectorStoreChunkingStrategyVariant2?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateThreadRequestToolResourcesFileSearchVectorStoreChunkingStrategyVariant2?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadRequestToolResourcesFileSearchVectorStoreChunkingStrategyVariant2Static.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadRequestToolResourcesFileSearchVectorStoreChunkingStrategyVariant2Static.g.cs
index a5cc39fc..e750935f 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadRequestToolResourcesFileSearchVectorStoreChunkingStrategyVariant2Static.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadRequestToolResourcesFileSearchVectorStoreChunkingStrategyVariant2Static.g.cs
@@ -86,5 +86,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateThreadRequestToolResourcesFileSearchVectorStoreChunkingStrategyVariant2Static?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateThreadRequestToolResourcesFileSearchVectorStoreChunkingStrategyVariant2Static),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateThreadRequestToolResourcesFileSearchVectorStoreChunkingStrategyVariant2Static;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateThreadRequestToolResourcesFileSearchVectorStoreChunkingStrategyVariant2Static?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateThreadRequestToolResourcesFileSearchVectorStoreChunkingStrategyVariant2Static?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadRequestToolResourcesFileSearchVectorStoreMetadata.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadRequestToolResourcesFileSearchVectorStoreMetadata.g.cs
index 04ccddeb..c0d002fd 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadRequestToolResourcesFileSearchVectorStoreMetadata.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateThreadRequestToolResourcesFileSearchVectorStoreMetadata.g.cs
@@ -72,5 +72,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateThreadRequestToolResourcesFileSearchVectorStoreMetadata?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateThreadRequestToolResourcesFileSearchVectorStoreMetadata),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateThreadRequestToolResourcesFileSearchVectorStoreMetadata;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateThreadRequestToolResourcesFileSearchVectorStoreMetadata?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateThreadRequestToolResourcesFileSearchVectorStoreMetadata?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateTranscriptionRequest.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateTranscriptionRequest.g.cs
index dadfa652..4c0fc932 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateTranscriptionRequest.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateTranscriptionRequest.g.cs
@@ -130,5 +130,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateTranscriptionRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateTranscriptionRequest),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateTranscriptionRequest;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateTranscriptionRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateTranscriptionRequest?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateTranscriptionResponseJson.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateTranscriptionResponseJson.g.cs
index 123f6c47..c496b798 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateTranscriptionResponseJson.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateTranscriptionResponseJson.g.cs
@@ -78,5 +78,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateTranscriptionResponseJson?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateTranscriptionResponseJson),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateTranscriptionResponseJson;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateTranscriptionResponseJson?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateTranscriptionResponseJson?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateTranscriptionResponseVerboseJson.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateTranscriptionResponseVerboseJson.g.cs
index 5d73ae46..d520e58a 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateTranscriptionResponseVerboseJson.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateTranscriptionResponseVerboseJson.g.cs
@@ -104,5 +104,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateTranscriptionResponseVerboseJson?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateTranscriptionResponseVerboseJson),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateTranscriptionResponseVerboseJson;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateTranscriptionResponseVerboseJson?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateTranscriptionResponseVerboseJson?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateTranslationRequest.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateTranslationRequest.g.cs
index e3c843a5..73b317e1 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateTranslationRequest.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateTranslationRequest.g.cs
@@ -117,5 +117,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateTranslationRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateTranslationRequest),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateTranslationRequest;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateTranslationRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateTranslationRequest?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateTranslationResponseJson.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateTranslationResponseJson.g.cs
index e0e9b0d9..8c5625c2 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateTranslationResponseJson.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateTranslationResponseJson.g.cs
@@ -78,5 +78,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateTranslationResponseJson?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateTranslationResponseJson),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateTranslationResponseJson;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateTranslationResponseJson?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateTranslationResponseJson?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateTranslationResponseVerboseJson.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateTranslationResponseVerboseJson.g.cs
index 3e4cfdb5..c346b13d 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateTranslationResponseVerboseJson.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateTranslationResponseVerboseJson.g.cs
@@ -98,5 +98,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateTranslationResponseVerboseJson?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateTranslationResponseVerboseJson),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateTranslationResponseVerboseJson;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateTranslationResponseVerboseJson?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateTranslationResponseVerboseJson?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateUploadRequest.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateUploadRequest.g.cs
index a68c95eb..8bb42c70 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateUploadRequest.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateUploadRequest.g.cs
@@ -102,5 +102,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateUploadRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateUploadRequest),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateUploadRequest;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateUploadRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateUploadRequest?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateVectorStoreFileBatchRequest.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateVectorStoreFileBatchRequest.g.cs
index 4bd0ca34..74e1c041 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateVectorStoreFileBatchRequest.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateVectorStoreFileBatchRequest.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateVectorStoreFileBatchRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateVectorStoreFileBatchRequest),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateVectorStoreFileBatchRequest;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateVectorStoreFileBatchRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateVectorStoreFileBatchRequest?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateVectorStoreFileRequest.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateVectorStoreFileRequest.g.cs
index 2b883df3..01d451de 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateVectorStoreFileRequest.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateVectorStoreFileRequest.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateVectorStoreFileRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateVectorStoreFileRequest),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateVectorStoreFileRequest;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateVectorStoreFileRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateVectorStoreFileRequest?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateVectorStoreRequest.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateVectorStoreRequest.g.cs
index 75e1d18c..b82e763a 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateVectorStoreRequest.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateVectorStoreRequest.g.cs
@@ -102,5 +102,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateVectorStoreRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateVectorStoreRequest),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateVectorStoreRequest;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateVectorStoreRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateVectorStoreRequest?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateVectorStoreRequestChunkingStrategy.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateVectorStoreRequestChunkingStrategy.g.cs
index 41ffb372..38c6ad11 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateVectorStoreRequestChunkingStrategy.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateVectorStoreRequestChunkingStrategy.g.cs
@@ -276,5 +276,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateVectorStoreRequestChunkingStrategy?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateVectorStoreRequestChunkingStrategy),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateVectorStoreRequestChunkingStrategy?;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateVectorStoreRequestChunkingStrategy?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateVectorStoreRequestChunkingStrategy?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateVectorStoreRequestChunkingStrategyDiscriminator.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateVectorStoreRequestChunkingStrategyDiscriminator.g.cs
index 3c11b141..12407d12 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateVectorStoreRequestChunkingStrategyDiscriminator.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateVectorStoreRequestChunkingStrategyDiscriminator.g.cs
@@ -78,5 +78,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateVectorStoreRequestChunkingStrategyDiscriminator?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateVectorStoreRequestChunkingStrategyDiscriminator),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateVectorStoreRequestChunkingStrategyDiscriminator;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateVectorStoreRequestChunkingStrategyDiscriminator?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateVectorStoreRequestChunkingStrategyDiscriminator?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.CreateVectorStoreRequestMetadata.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.CreateVectorStoreRequestMetadata.g.cs
index aad6cc60..17adeacb 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.CreateVectorStoreRequestMetadata.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.CreateVectorStoreRequestMetadata.g.cs
@@ -72,5 +72,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateVectorStoreRequestMetadata?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.CreateVectorStoreRequestMetadata),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.CreateVectorStoreRequestMetadata;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.CreateVectorStoreRequestMetadata?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.CreateVectorStoreRequestMetadata?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.DefaultProjectErrorResponse.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.DefaultProjectErrorResponse.g.cs
index 1dcad0bf..92a14888 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.DefaultProjectErrorResponse.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.DefaultProjectErrorResponse.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.DefaultProjectErrorResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.DefaultProjectErrorResponse),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.DefaultProjectErrorResponse;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.DefaultProjectErrorResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.DefaultProjectErrorResponse?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.DeleteAssistantResponse.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.DeleteAssistantResponse.g.cs
index f89407d1..b287da5f 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.DeleteAssistantResponse.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.DeleteAssistantResponse.g.cs
@@ -92,5 +92,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.DeleteAssistantResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.DeleteAssistantResponse),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.DeleteAssistantResponse;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.DeleteAssistantResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.DeleteAssistantResponse?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.DeleteFileResponse.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.DeleteFileResponse.g.cs
index 78628d6b..3d3f02f2 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.DeleteFileResponse.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.DeleteFileResponse.g.cs
@@ -92,5 +92,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.DeleteFileResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.DeleteFileResponse),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.DeleteFileResponse;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.DeleteFileResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.DeleteFileResponse?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.DeleteMessageResponse.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.DeleteMessageResponse.g.cs
index 05bc6170..48ca45c7 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.DeleteMessageResponse.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.DeleteMessageResponse.g.cs
@@ -92,5 +92,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.DeleteMessageResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.DeleteMessageResponse),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.DeleteMessageResponse;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.DeleteMessageResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.DeleteMessageResponse?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.DeleteModelResponse.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.DeleteModelResponse.g.cs
index 35c4e72d..9d80cfa3 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.DeleteModelResponse.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.DeleteModelResponse.g.cs
@@ -92,5 +92,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.DeleteModelResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.DeleteModelResponse),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.DeleteModelResponse;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.DeleteModelResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.DeleteModelResponse?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.DeleteThreadResponse.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.DeleteThreadResponse.g.cs
index 56b0bfff..821facc6 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.DeleteThreadResponse.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.DeleteThreadResponse.g.cs
@@ -92,5 +92,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.DeleteThreadResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.DeleteThreadResponse),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.DeleteThreadResponse;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.DeleteThreadResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.DeleteThreadResponse?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.DeleteVectorStoreFileResponse.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.DeleteVectorStoreFileResponse.g.cs
index c8c6690b..842fa43c 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.DeleteVectorStoreFileResponse.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.DeleteVectorStoreFileResponse.g.cs
@@ -92,5 +92,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.DeleteVectorStoreFileResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.DeleteVectorStoreFileResponse),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.DeleteVectorStoreFileResponse;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.DeleteVectorStoreFileResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.DeleteVectorStoreFileResponse?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.DeleteVectorStoreResponse.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.DeleteVectorStoreResponse.g.cs
index 394994e9..e1e1735c 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.DeleteVectorStoreResponse.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.DeleteVectorStoreResponse.g.cs
@@ -92,5 +92,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.DeleteVectorStoreResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.DeleteVectorStoreResponse),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.DeleteVectorStoreResponse;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.DeleteVectorStoreResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.DeleteVectorStoreResponse?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.DoneEvent.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.DoneEvent.g.cs
index fce0664b..53235cfe 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.DoneEvent.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.DoneEvent.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.DoneEvent?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.DoneEvent),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.DoneEvent;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.DoneEvent?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.DoneEvent?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.Embedding.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.Embedding.g.cs
index b3a6968b..80641421 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.Embedding.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.Embedding.g.cs
@@ -92,5 +92,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.Embedding?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.Embedding),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.Embedding;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.Embedding?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.Embedding?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.Error.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.Error.g.cs
index 2530e73a..d82b33a8 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.Error.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.Error.g.cs
@@ -99,5 +99,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.Error?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.Error),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.Error;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.Error?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.Error?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ErrorEvent.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ErrorEvent.g.cs
index c4317b5b..41312e89 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ErrorEvent.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ErrorEvent.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ErrorEvent?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ErrorEvent),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ErrorEvent;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ErrorEvent?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ErrorEvent?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ErrorResponse.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ErrorResponse.g.cs
index c7001fc5..60666f14 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ErrorResponse.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ErrorResponse.g.cs
@@ -78,5 +78,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ErrorResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ErrorResponse),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ErrorResponse;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ErrorResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ErrorResponse?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.FileSearchRankingOptions.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.FileSearchRankingOptions.g.cs
index e2924313..0b904df2 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.FileSearchRankingOptions.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.FileSearchRankingOptions.g.cs
@@ -86,5 +86,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.FileSearchRankingOptions?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.FileSearchRankingOptions),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.FileSearchRankingOptions;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.FileSearchRankingOptions?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.FileSearchRankingOptions?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.FineTuneChatCompletionRequestAssistantMessage.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.FineTuneChatCompletionRequestAssistantMessage.g.cs
index 608f4415..1d2487b1 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.FineTuneChatCompletionRequestAssistantMessage.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.FineTuneChatCompletionRequestAssistantMessage.g.cs
@@ -268,5 +268,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.FineTuneChatCompletionRequestAssistantMessage?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.FineTuneChatCompletionRequestAssistantMessage),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.FineTuneChatCompletionRequestAssistantMessage?;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.FineTuneChatCompletionRequestAssistantMessage?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.FineTuneChatCompletionRequestAssistantMessage?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.FineTuneChatCompletionRequestAssistantMessageVariant1.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.FineTuneChatCompletionRequestAssistantMessageVariant1.g.cs
index 3ab7d6c8..2e36c922 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.FineTuneChatCompletionRequestAssistantMessageVariant1.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.FineTuneChatCompletionRequestAssistantMessageVariant1.g.cs
@@ -77,5 +77,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.FineTuneChatCompletionRequestAssistantMessageVariant1?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.FineTuneChatCompletionRequestAssistantMessageVariant1),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.FineTuneChatCompletionRequestAssistantMessageVariant1;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.FineTuneChatCompletionRequestAssistantMessageVariant1?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.FineTuneChatCompletionRequestAssistantMessageVariant1?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.FineTuningIntegration.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.FineTuningIntegration.g.cs
index e5c37717..82976087 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.FineTuningIntegration.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.FineTuningIntegration.g.cs
@@ -87,5 +87,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.FineTuningIntegration?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.FineTuningIntegration),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.FineTuningIntegration;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.FineTuningIntegration?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.FineTuningIntegration?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.FineTuningIntegrationWandb.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.FineTuningIntegrationWandb.g.cs
index 172b2956..ac286000 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.FineTuningIntegrationWandb.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.FineTuningIntegrationWandb.g.cs
@@ -101,5 +101,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.FineTuningIntegrationWandb?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.FineTuningIntegrationWandb),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.FineTuningIntegrationWandb;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.FineTuningIntegrationWandb?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.FineTuningIntegrationWandb?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.FineTuningJob.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.FineTuningJob.g.cs
index ace6355f..6da4d42b 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.FineTuningJob.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.FineTuningJob.g.cs
@@ -194,5 +194,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.FineTuningJob?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.FineTuningJob),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.FineTuningJob;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.FineTuningJob?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.FineTuningJob?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.FineTuningJobCheckpoint.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.FineTuningJobCheckpoint.g.cs
index e2e11b1e..a28c0273 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.FineTuningJobCheckpoint.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.FineTuningJobCheckpoint.g.cs
@@ -121,5 +121,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.FineTuningJobCheckpoint?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.FineTuningJobCheckpoint),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.FineTuningJobCheckpoint;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.FineTuningJobCheckpoint?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.FineTuningJobCheckpoint?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.FineTuningJobCheckpointMetrics.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.FineTuningJobCheckpointMetrics.g.cs
index d460cbd5..2eba8514 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.FineTuningJobCheckpointMetrics.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.FineTuningJobCheckpointMetrics.g.cs
@@ -113,5 +113,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.FineTuningJobCheckpointMetrics?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.FineTuningJobCheckpointMetrics),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.FineTuningJobCheckpointMetrics;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.FineTuningJobCheckpointMetrics?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.FineTuningJobCheckpointMetrics?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.FineTuningJobError.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.FineTuningJobError.g.cs
index 07316a16..77982d0f 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.FineTuningJobError.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.FineTuningJobError.g.cs
@@ -92,5 +92,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.FineTuningJobError?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.FineTuningJobError),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.FineTuningJobError;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.FineTuningJobError?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.FineTuningJobError?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.FineTuningJobEvent.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.FineTuningJobEvent.g.cs
index f84b9cf1..84f7cfc9 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.FineTuningJobEvent.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.FineTuningJobEvent.g.cs
@@ -107,5 +107,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.FineTuningJobEvent?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.FineTuningJobEvent),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.FineTuningJobEvent;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.FineTuningJobEvent?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.FineTuningJobEvent?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.FineTuningJobHyperparameters.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.FineTuningJobHyperparameters.g.cs
index dd1deeb4..263de5d9 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.FineTuningJobHyperparameters.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.FineTuningJobHyperparameters.g.cs
@@ -83,5 +83,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.FineTuningJobHyperparameters?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.FineTuningJobHyperparameters),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.FineTuningJobHyperparameters;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.FineTuningJobHyperparameters?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.FineTuningJobHyperparameters?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.FinetuneChatRequestInput.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.FinetuneChatRequestInput.g.cs
index 0690c3c2..2e47f6ea 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.FinetuneChatRequestInput.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.FinetuneChatRequestInput.g.cs
@@ -98,5 +98,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.FinetuneChatRequestInput?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.FinetuneChatRequestInput),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.FinetuneChatRequestInput;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.FinetuneChatRequestInput?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.FinetuneChatRequestInput?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.FinetuneCompletionRequestInput.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.FinetuneCompletionRequestInput.g.cs
index 1a879964..30d9d0b7 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.FinetuneCompletionRequestInput.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.FinetuneCompletionRequestInput.g.cs
@@ -83,5 +83,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.FinetuneCompletionRequestInput?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.FinetuneCompletionRequestInput),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.FinetuneCompletionRequestInput;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.FinetuneCompletionRequestInput?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.FinetuneCompletionRequestInput?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.FunctionObject.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.FunctionObject.g.cs
index d8c76f77..e5af6fbf 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.FunctionObject.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.FunctionObject.g.cs
@@ -98,5 +98,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.FunctionObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.FunctionObject),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.FunctionObject;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.FunctionObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.FunctionObject?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.FunctionParameters.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.FunctionParameters.g.cs
index 2c60541f..136335ac 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.FunctionParameters.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.FunctionParameters.g.cs
@@ -73,5 +73,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.FunctionParameters?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.FunctionParameters),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.FunctionParameters;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.FunctionParameters?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.FunctionParameters?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.Image.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.Image.g.cs
index de709929..6b9f371c 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.Image.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.Image.g.cs
@@ -89,5 +89,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.Image?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.Image),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.Image;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.Image?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.Image?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ImagesResponse.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ImagesResponse.g.cs
index 5d0a12bb..45578d22 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ImagesResponse.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ImagesResponse.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ImagesResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ImagesResponse),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ImagesResponse;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ImagesResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ImagesResponse?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.InputVariant3Item.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.InputVariant3Item.g.cs
index 7673e930..efcda81e 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.InputVariant3Item.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.InputVariant3Item.g.cs
@@ -276,5 +276,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.InputVariant3Item?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.InputVariant3Item),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.InputVariant3Item?;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.InputVariant3Item?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.InputVariant3Item?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.Invite.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.Invite.g.cs
index d96406d5..6b27e8a2 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.Invite.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.Invite.g.cs
@@ -131,5 +131,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.Invite?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.Invite),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.Invite;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.Invite?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.Invite?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.InviteDeleteResponse.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.InviteDeleteResponse.g.cs
index acb9aa07..b6a67f41 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.InviteDeleteResponse.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.InviteDeleteResponse.g.cs
@@ -92,5 +92,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.InviteDeleteResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.InviteDeleteResponse),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.InviteDeleteResponse;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.InviteDeleteResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.InviteDeleteResponse?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.InviteListResponse.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.InviteListResponse.g.cs
index 60472cd7..1f67eef3 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.InviteListResponse.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.InviteListResponse.g.cs
@@ -103,5 +103,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.InviteListResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.InviteListResponse),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.InviteListResponse;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.InviteListResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.InviteListResponse?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.InviteRequest.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.InviteRequest.g.cs
index 0354617f..43796cb3 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.InviteRequest.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.InviteRequest.g.cs
@@ -86,5 +86,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.InviteRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.InviteRequest),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.InviteRequest;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.InviteRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.InviteRequest?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ListAssistantsResponse.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ListAssistantsResponse.g.cs
index 9eaf45bb..a1915261 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ListAssistantsResponse.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ListAssistantsResponse.g.cs
@@ -106,5 +106,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ListAssistantsResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ListAssistantsResponse),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ListAssistantsResponse;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ListAssistantsResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ListAssistantsResponse?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ListAuditLogsEffectiveAt.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ListAuditLogsEffectiveAt.g.cs
index 7f86acb4..a6537a6e 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ListAuditLogsEffectiveAt.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ListAuditLogsEffectiveAt.g.cs
@@ -95,5 +95,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ListAuditLogsEffectiveAt?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ListAuditLogsEffectiveAt),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ListAuditLogsEffectiveAt;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ListAuditLogsEffectiveAt?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ListAuditLogsEffectiveAt?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ListAuditLogsResponse.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ListAuditLogsResponse.g.cs
index 84489569..d5d2dc09 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ListAuditLogsResponse.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ListAuditLogsResponse.g.cs
@@ -106,5 +106,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ListAuditLogsResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ListAuditLogsResponse),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ListAuditLogsResponse;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ListAuditLogsResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ListAuditLogsResponse?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ListBatchesResponse.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ListBatchesResponse.g.cs
index 5794cf8e..6c085cf5 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ListBatchesResponse.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ListBatchesResponse.g.cs
@@ -104,5 +104,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ListBatchesResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ListBatchesResponse),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ListBatchesResponse;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ListBatchesResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ListBatchesResponse?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ListFilesResponse.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ListFilesResponse.g.cs
index f708b71b..2254a519 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ListFilesResponse.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ListFilesResponse.g.cs
@@ -106,5 +106,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ListFilesResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ListFilesResponse),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ListFilesResponse;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ListFilesResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ListFilesResponse?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ListFineTuningJobCheckpointsResponse.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ListFineTuningJobCheckpointsResponse.g.cs
index 4b3c7ff3..8dfc7f78 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ListFineTuningJobCheckpointsResponse.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ListFineTuningJobCheckpointsResponse.g.cs
@@ -104,5 +104,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ListFineTuningJobCheckpointsResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ListFineTuningJobCheckpointsResponse),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ListFineTuningJobCheckpointsResponse;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ListFineTuningJobCheckpointsResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ListFineTuningJobCheckpointsResponse?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ListFineTuningJobEventsResponse.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ListFineTuningJobEventsResponse.g.cs
index 7bb3596f..10e72242 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ListFineTuningJobEventsResponse.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ListFineTuningJobEventsResponse.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ListFineTuningJobEventsResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ListFineTuningJobEventsResponse),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ListFineTuningJobEventsResponse;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ListFineTuningJobEventsResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ListFineTuningJobEventsResponse?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ListMessagesResponse.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ListMessagesResponse.g.cs
index 4054c366..dd536a04 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ListMessagesResponse.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ListMessagesResponse.g.cs
@@ -106,5 +106,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ListMessagesResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ListMessagesResponse),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ListMessagesResponse;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ListMessagesResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ListMessagesResponse?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ListModelsResponse.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ListModelsResponse.g.cs
index 2a563f4d..df698b8a 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ListModelsResponse.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ListModelsResponse.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ListModelsResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ListModelsResponse),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ListModelsResponse;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ListModelsResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ListModelsResponse?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ListPaginatedFineTuningJobsResponse.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ListPaginatedFineTuningJobsResponse.g.cs
index 2b8facee..fee86cc3 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ListPaginatedFineTuningJobsResponse.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ListPaginatedFineTuningJobsResponse.g.cs
@@ -92,5 +92,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ListPaginatedFineTuningJobsResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ListPaginatedFineTuningJobsResponse),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ListPaginatedFineTuningJobsResponse;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ListPaginatedFineTuningJobsResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ListPaginatedFineTuningJobsResponse?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ListRunStepsResponse.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ListRunStepsResponse.g.cs
index 15a396f7..3f35d894 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ListRunStepsResponse.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ListRunStepsResponse.g.cs
@@ -106,5 +106,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ListRunStepsResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ListRunStepsResponse),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ListRunStepsResponse;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ListRunStepsResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ListRunStepsResponse?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ListRunsResponse.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ListRunsResponse.g.cs
index 4180f77a..04f34d55 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ListRunsResponse.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ListRunsResponse.g.cs
@@ -106,5 +106,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ListRunsResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ListRunsResponse),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ListRunsResponse;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ListRunsResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ListRunsResponse?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ListThreadsResponse.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ListThreadsResponse.g.cs
index de1254a5..03b7bf87 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ListThreadsResponse.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ListThreadsResponse.g.cs
@@ -106,5 +106,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ListThreadsResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ListThreadsResponse),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ListThreadsResponse;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ListThreadsResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ListThreadsResponse?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ListVectorStoreFilesResponse.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ListVectorStoreFilesResponse.g.cs
index c48503f9..abce8ec7 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ListVectorStoreFilesResponse.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ListVectorStoreFilesResponse.g.cs
@@ -106,5 +106,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ListVectorStoreFilesResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ListVectorStoreFilesResponse),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ListVectorStoreFilesResponse;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ListVectorStoreFilesResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ListVectorStoreFilesResponse?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ListVectorStoresResponse.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ListVectorStoresResponse.g.cs
index 707408df..3cf61510 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ListVectorStoresResponse.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ListVectorStoresResponse.g.cs
@@ -106,5 +106,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ListVectorStoresResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ListVectorStoresResponse),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ListVectorStoresResponse;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ListVectorStoresResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ListVectorStoresResponse?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.MessageContentImageFileObject.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.MessageContentImageFileObject.g.cs
index 5f91d8a9..33fa9864 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.MessageContentImageFileObject.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.MessageContentImageFileObject.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.MessageContentImageFileObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.MessageContentImageFileObject),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.MessageContentImageFileObject;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.MessageContentImageFileObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.MessageContentImageFileObject?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.MessageContentImageFileObjectImageFile.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.MessageContentImageFileObjectImageFile.g.cs
index 2abfe226..274ea59a 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.MessageContentImageFileObjectImageFile.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.MessageContentImageFileObjectImageFile.g.cs
@@ -86,5 +86,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.MessageContentImageFileObjectImageFile?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.MessageContentImageFileObjectImageFile),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.MessageContentImageFileObjectImageFile;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.MessageContentImageFileObjectImageFile?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.MessageContentImageFileObjectImageFile?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.MessageContentImageUrlObject.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.MessageContentImageUrlObject.g.cs
index 540d390b..ef6140ba 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.MessageContentImageUrlObject.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.MessageContentImageUrlObject.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.MessageContentImageUrlObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.MessageContentImageUrlObject),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.MessageContentImageUrlObject;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.MessageContentImageUrlObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.MessageContentImageUrlObject?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.MessageContentImageUrlObjectImageUrl.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.MessageContentImageUrlObjectImageUrl.g.cs
index a8935891..8e3f20cb 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.MessageContentImageUrlObjectImageUrl.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.MessageContentImageUrlObjectImageUrl.g.cs
@@ -86,5 +86,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.MessageContentImageUrlObjectImageUrl?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.MessageContentImageUrlObjectImageUrl),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.MessageContentImageUrlObjectImageUrl;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.MessageContentImageUrlObjectImageUrl?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.MessageContentImageUrlObjectImageUrl?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.MessageContentRefusalObject.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.MessageContentRefusalObject.g.cs
index 61b21a14..f13b4d1a 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.MessageContentRefusalObject.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.MessageContentRefusalObject.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.MessageContentRefusalObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.MessageContentRefusalObject),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.MessageContentRefusalObject;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.MessageContentRefusalObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.MessageContentRefusalObject?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.MessageContentTextAnnotationsFileCitationObject.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.MessageContentTextAnnotationsFileCitationObject.g.cs
index 4c448254..cb514641 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.MessageContentTextAnnotationsFileCitationObject.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.MessageContentTextAnnotationsFileCitationObject.g.cs
@@ -106,5 +106,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.MessageContentTextAnnotationsFileCitationObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.MessageContentTextAnnotationsFileCitationObject),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.MessageContentTextAnnotationsFileCitationObject;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.MessageContentTextAnnotationsFileCitationObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.MessageContentTextAnnotationsFileCitationObject?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.MessageContentTextAnnotationsFileCitationObjectFileCitation.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.MessageContentTextAnnotationsFileCitationObjectFileCitation.g.cs
index dcc409c8..f522053b 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.MessageContentTextAnnotationsFileCitationObjectFileCitation.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.MessageContentTextAnnotationsFileCitationObjectFileCitation.g.cs
@@ -78,5 +78,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.MessageContentTextAnnotationsFileCitationObjectFileCitation?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.MessageContentTextAnnotationsFileCitationObjectFileCitation),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.MessageContentTextAnnotationsFileCitationObjectFileCitation;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.MessageContentTextAnnotationsFileCitationObjectFileCitation?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.MessageContentTextAnnotationsFileCitationObjectFileCitation?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.MessageContentTextAnnotationsFilePathObject.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.MessageContentTextAnnotationsFilePathObject.g.cs
index eb8e5f19..cb6f3c08 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.MessageContentTextAnnotationsFilePathObject.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.MessageContentTextAnnotationsFilePathObject.g.cs
@@ -106,5 +106,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.MessageContentTextAnnotationsFilePathObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.MessageContentTextAnnotationsFilePathObject),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.MessageContentTextAnnotationsFilePathObject;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.MessageContentTextAnnotationsFilePathObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.MessageContentTextAnnotationsFilePathObject?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.MessageContentTextAnnotationsFilePathObjectFilePath.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.MessageContentTextAnnotationsFilePathObjectFilePath.g.cs
index 2b36d54e..15a7ce87 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.MessageContentTextAnnotationsFilePathObjectFilePath.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.MessageContentTextAnnotationsFilePathObjectFilePath.g.cs
@@ -78,5 +78,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.MessageContentTextAnnotationsFilePathObjectFilePath?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.MessageContentTextAnnotationsFilePathObjectFilePath),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.MessageContentTextAnnotationsFilePathObjectFilePath;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.MessageContentTextAnnotationsFilePathObjectFilePath?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.MessageContentTextAnnotationsFilePathObjectFilePath?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.MessageContentTextObject.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.MessageContentTextObject.g.cs
index 1b9a0197..a3d777e3 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.MessageContentTextObject.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.MessageContentTextObject.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.MessageContentTextObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.MessageContentTextObject),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.MessageContentTextObject;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.MessageContentTextObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.MessageContentTextObject?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.MessageContentTextObjectText.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.MessageContentTextObjectText.g.cs
index b33baf58..da94cf36 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.MessageContentTextObjectText.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.MessageContentTextObjectText.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.MessageContentTextObjectText?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.MessageContentTextObjectText),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.MessageContentTextObjectText;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.MessageContentTextObjectText?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.MessageContentTextObjectText?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.MessageContentTextObjectTextAnnotationDiscriminator.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.MessageContentTextObjectTextAnnotationDiscriminator.g.cs
index 13b313bf..c3648380 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.MessageContentTextObjectTextAnnotationDiscriminator.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.MessageContentTextObjectTextAnnotationDiscriminator.g.cs
@@ -78,5 +78,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.MessageContentTextObjectTextAnnotationDiscriminator?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.MessageContentTextObjectTextAnnotationDiscriminator),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.MessageContentTextObjectTextAnnotationDiscriminator;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.MessageContentTextObjectTextAnnotationDiscriminator?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.MessageContentTextObjectTextAnnotationDiscriminator?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.MessageDeltaContentImageFileObject.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.MessageDeltaContentImageFileObject.g.cs
index c6956797..663c56ba 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.MessageDeltaContentImageFileObject.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.MessageDeltaContentImageFileObject.g.cs
@@ -91,5 +91,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.MessageDeltaContentImageFileObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.MessageDeltaContentImageFileObject),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.MessageDeltaContentImageFileObject;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.MessageDeltaContentImageFileObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.MessageDeltaContentImageFileObject?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.MessageDeltaContentImageFileObjectImageFile.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.MessageDeltaContentImageFileObjectImageFile.g.cs
index 84bac722..2cdd88d2 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.MessageDeltaContentImageFileObjectImageFile.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.MessageDeltaContentImageFileObjectImageFile.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.MessageDeltaContentImageFileObjectImageFile?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.MessageDeltaContentImageFileObjectImageFile),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.MessageDeltaContentImageFileObjectImageFile;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.MessageDeltaContentImageFileObjectImageFile?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.MessageDeltaContentImageFileObjectImageFile?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.MessageDeltaContentImageUrlObject.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.MessageDeltaContentImageUrlObject.g.cs
index 69674703..635f7088 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.MessageDeltaContentImageUrlObject.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.MessageDeltaContentImageUrlObject.g.cs
@@ -91,5 +91,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.MessageDeltaContentImageUrlObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.MessageDeltaContentImageUrlObject),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.MessageDeltaContentImageUrlObject;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.MessageDeltaContentImageUrlObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.MessageDeltaContentImageUrlObject?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.MessageDeltaContentImageUrlObjectImageUrl.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.MessageDeltaContentImageUrlObjectImageUrl.g.cs
index d3bd07dd..dd4835a8 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.MessageDeltaContentImageUrlObjectImageUrl.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.MessageDeltaContentImageUrlObjectImageUrl.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.MessageDeltaContentImageUrlObjectImageUrl?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.MessageDeltaContentImageUrlObjectImageUrl),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.MessageDeltaContentImageUrlObjectImageUrl;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.MessageDeltaContentImageUrlObjectImageUrl?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.MessageDeltaContentImageUrlObjectImageUrl?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.MessageDeltaContentRefusalObject.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.MessageDeltaContentRefusalObject.g.cs
index 90764850..b2f97e20 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.MessageDeltaContentRefusalObject.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.MessageDeltaContentRefusalObject.g.cs
@@ -91,5 +91,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.MessageDeltaContentRefusalObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.MessageDeltaContentRefusalObject),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.MessageDeltaContentRefusalObject;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.MessageDeltaContentRefusalObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.MessageDeltaContentRefusalObject?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.MessageDeltaContentTextAnnotationsFileCitationObject.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.MessageDeltaContentTextAnnotationsFileCitationObject.g.cs
index f40841ff..62c7d4fc 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.MessageDeltaContentTextAnnotationsFileCitationObject.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.MessageDeltaContentTextAnnotationsFileCitationObject.g.cs
@@ -109,5 +109,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.MessageDeltaContentTextAnnotationsFileCitationObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.MessageDeltaContentTextAnnotationsFileCitationObject),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.MessageDeltaContentTextAnnotationsFileCitationObject;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.MessageDeltaContentTextAnnotationsFileCitationObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.MessageDeltaContentTextAnnotationsFileCitationObject?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.MessageDeltaContentTextAnnotationsFileCitationObjectFileCitation.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.MessageDeltaContentTextAnnotationsFileCitationObjectFileCitation.g.cs
index ae3097f1..7813b927 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.MessageDeltaContentTextAnnotationsFileCitationObjectFileCitation.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.MessageDeltaContentTextAnnotationsFileCitationObjectFileCitation.g.cs
@@ -83,5 +83,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.MessageDeltaContentTextAnnotationsFileCitationObjectFileCitation?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.MessageDeltaContentTextAnnotationsFileCitationObjectFileCitation),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.MessageDeltaContentTextAnnotationsFileCitationObjectFileCitation;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.MessageDeltaContentTextAnnotationsFileCitationObjectFileCitation?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.MessageDeltaContentTextAnnotationsFileCitationObjectFileCitation?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.MessageDeltaContentTextAnnotationsFilePathObject.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.MessageDeltaContentTextAnnotationsFilePathObject.g.cs
index b3109071..54a2e5da 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.MessageDeltaContentTextAnnotationsFilePathObject.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.MessageDeltaContentTextAnnotationsFilePathObject.g.cs
@@ -109,5 +109,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.MessageDeltaContentTextAnnotationsFilePathObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.MessageDeltaContentTextAnnotationsFilePathObject),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.MessageDeltaContentTextAnnotationsFilePathObject;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.MessageDeltaContentTextAnnotationsFilePathObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.MessageDeltaContentTextAnnotationsFilePathObject?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.MessageDeltaContentTextAnnotationsFilePathObjectFilePath.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.MessageDeltaContentTextAnnotationsFilePathObjectFilePath.g.cs
index e2c00723..1445e3ce 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.MessageDeltaContentTextAnnotationsFilePathObjectFilePath.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.MessageDeltaContentTextAnnotationsFilePathObjectFilePath.g.cs
@@ -77,5 +77,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.MessageDeltaContentTextAnnotationsFilePathObjectFilePath?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.MessageDeltaContentTextAnnotationsFilePathObjectFilePath),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.MessageDeltaContentTextAnnotationsFilePathObjectFilePath;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.MessageDeltaContentTextAnnotationsFilePathObjectFilePath?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.MessageDeltaContentTextAnnotationsFilePathObjectFilePath?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.MessageDeltaContentTextObject.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.MessageDeltaContentTextObject.g.cs
index 148a0c4e..74c59e91 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.MessageDeltaContentTextObject.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.MessageDeltaContentTextObject.g.cs
@@ -91,5 +91,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.MessageDeltaContentTextObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.MessageDeltaContentTextObject),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.MessageDeltaContentTextObject;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.MessageDeltaContentTextObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.MessageDeltaContentTextObject?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.MessageDeltaContentTextObjectText.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.MessageDeltaContentTextObjectText.g.cs
index ff024899..b8e3a25c 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.MessageDeltaContentTextObjectText.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.MessageDeltaContentTextObjectText.g.cs
@@ -83,5 +83,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.MessageDeltaContentTextObjectText?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.MessageDeltaContentTextObjectText),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.MessageDeltaContentTextObjectText;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.MessageDeltaContentTextObjectText?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.MessageDeltaContentTextObjectText?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.MessageDeltaContentTextObjectTextAnnotationDiscriminator.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.MessageDeltaContentTextObjectTextAnnotationDiscriminator.g.cs
index 97a39336..a64e2dd1 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.MessageDeltaContentTextObjectTextAnnotationDiscriminator.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.MessageDeltaContentTextObjectTextAnnotationDiscriminator.g.cs
@@ -78,5 +78,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.MessageDeltaContentTextObjectTextAnnotationDiscriminator?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.MessageDeltaContentTextObjectTextAnnotationDiscriminator),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.MessageDeltaContentTextObjectTextAnnotationDiscriminator;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.MessageDeltaContentTextObjectTextAnnotationDiscriminator?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.MessageDeltaContentTextObjectTextAnnotationDiscriminator?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.MessageDeltaObject.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.MessageDeltaObject.g.cs
index 6659e3ad..0d30a862 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.MessageDeltaObject.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.MessageDeltaObject.g.cs
@@ -92,5 +92,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.MessageDeltaObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.MessageDeltaObject),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.MessageDeltaObject;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.MessageDeltaObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.MessageDeltaObject?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.MessageDeltaObjectDelta.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.MessageDeltaObjectDelta.g.cs
index cdb66f67..b8803da7 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.MessageDeltaObjectDelta.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.MessageDeltaObjectDelta.g.cs
@@ -84,5 +84,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.MessageDeltaObjectDelta?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.MessageDeltaObjectDelta),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.MessageDeltaObjectDelta;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.MessageDeltaObjectDelta?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.MessageDeltaObjectDelta?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.MessageDeltaObjectDeltaContentItemDiscriminator.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.MessageDeltaObjectDeltaContentItemDiscriminator.g.cs
index b27dcd67..c68b0865 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.MessageDeltaObjectDeltaContentItemDiscriminator.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.MessageDeltaObjectDeltaContentItemDiscriminator.g.cs
@@ -78,5 +78,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.MessageDeltaObjectDeltaContentItemDiscriminator?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.MessageDeltaObjectDeltaContentItemDiscriminator),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.MessageDeltaObjectDeltaContentItemDiscriminator;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.MessageDeltaObjectDeltaContentItemDiscriminator?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.MessageDeltaObjectDeltaContentItemDiscriminator?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.MessageObject.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.MessageObject.g.cs
index 7bc41591..4a739ecd 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.MessageObject.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.MessageObject.g.cs
@@ -170,5 +170,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.MessageObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.MessageObject),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.MessageObject;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.MessageObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.MessageObject?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.MessageObjectAttachment.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.MessageObjectAttachment.g.cs
index 863af0dd..afd9c668 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.MessageObjectAttachment.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.MessageObjectAttachment.g.cs
@@ -83,5 +83,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.MessageObjectAttachment?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.MessageObjectAttachment),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.MessageObjectAttachment;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.MessageObjectAttachment?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.MessageObjectAttachment?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.MessageObjectAttachmentToolDiscriminator.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.MessageObjectAttachmentToolDiscriminator.g.cs
index 00abd03d..d66e8b77 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.MessageObjectAttachmentToolDiscriminator.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.MessageObjectAttachmentToolDiscriminator.g.cs
@@ -78,5 +78,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.MessageObjectAttachmentToolDiscriminator?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.MessageObjectAttachmentToolDiscriminator),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.MessageObjectAttachmentToolDiscriminator;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.MessageObjectAttachmentToolDiscriminator?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.MessageObjectAttachmentToolDiscriminator?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.MessageObjectContentItemDiscriminator.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.MessageObjectContentItemDiscriminator.g.cs
index 79f7d305..c19b5fc5 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.MessageObjectContentItemDiscriminator.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.MessageObjectContentItemDiscriminator.g.cs
@@ -78,5 +78,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.MessageObjectContentItemDiscriminator?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.MessageObjectContentItemDiscriminator),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.MessageObjectContentItemDiscriminator;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.MessageObjectContentItemDiscriminator?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.MessageObjectContentItemDiscriminator?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.MessageObjectIncompleteDetails.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.MessageObjectIncompleteDetails.g.cs
index ced8a4e1..255b22c5 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.MessageObjectIncompleteDetails.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.MessageObjectIncompleteDetails.g.cs
@@ -79,5 +79,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.MessageObjectIncompleteDetails?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.MessageObjectIncompleteDetails),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.MessageObjectIncompleteDetails;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.MessageObjectIncompleteDetails?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.MessageObjectIncompleteDetails?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.MessageObjectMetadata.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.MessageObjectMetadata.g.cs
index 182cdcdf..3631e0e6 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.MessageObjectMetadata.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.MessageObjectMetadata.g.cs
@@ -72,5 +72,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.MessageObjectMetadata?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.MessageObjectMetadata),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.MessageObjectMetadata;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.MessageObjectMetadata?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.MessageObjectMetadata?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.MessageRequestContentTextObject.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.MessageRequestContentTextObject.g.cs
index 0142c7ea..b08d2dda 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.MessageRequestContentTextObject.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.MessageRequestContentTextObject.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.MessageRequestContentTextObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.MessageRequestContentTextObject),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.MessageRequestContentTextObject;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.MessageRequestContentTextObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.MessageRequestContentTextObject?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.Model15.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.Model15.g.cs
index a70cec8f..a40ad67c 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.Model15.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.Model15.g.cs
@@ -100,5 +100,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.Model15?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.Model15),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.Model15;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.Model15?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.Model15?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ModifyAssistantRequest.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ModifyAssistantRequest.g.cs
index 3f6e0f13..2f7cc744 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ModifyAssistantRequest.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ModifyAssistantRequest.g.cs
@@ -140,5 +140,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ModifyAssistantRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ModifyAssistantRequest),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ModifyAssistantRequest;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ModifyAssistantRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ModifyAssistantRequest?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ModifyAssistantRequestMetadata.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ModifyAssistantRequestMetadata.g.cs
index 26de1ff0..be2be017 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ModifyAssistantRequestMetadata.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ModifyAssistantRequestMetadata.g.cs
@@ -72,5 +72,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ModifyAssistantRequestMetadata?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ModifyAssistantRequestMetadata),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ModifyAssistantRequestMetadata;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ModifyAssistantRequestMetadata?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ModifyAssistantRequestMetadata?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ModifyAssistantRequestToolDiscriminator.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ModifyAssistantRequestToolDiscriminator.g.cs
index c606e80b..8dcff745 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ModifyAssistantRequestToolDiscriminator.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ModifyAssistantRequestToolDiscriminator.g.cs
@@ -78,5 +78,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ModifyAssistantRequestToolDiscriminator?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ModifyAssistantRequestToolDiscriminator),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ModifyAssistantRequestToolDiscriminator;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ModifyAssistantRequestToolDiscriminator?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ModifyAssistantRequestToolDiscriminator?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ModifyAssistantRequestToolResources.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ModifyAssistantRequestToolResources.g.cs
index 3d68a90f..5eb5d0c0 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ModifyAssistantRequestToolResources.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ModifyAssistantRequestToolResources.g.cs
@@ -83,5 +83,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ModifyAssistantRequestToolResources?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ModifyAssistantRequestToolResources),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ModifyAssistantRequestToolResources;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ModifyAssistantRequestToolResources?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ModifyAssistantRequestToolResources?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ModifyAssistantRequestToolResourcesCodeInterpreter.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ModifyAssistantRequestToolResourcesCodeInterpreter.g.cs
index 34ac8243..55e3ceb8 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ModifyAssistantRequestToolResourcesCodeInterpreter.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ModifyAssistantRequestToolResourcesCodeInterpreter.g.cs
@@ -77,5 +77,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ModifyAssistantRequestToolResourcesCodeInterpreter?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ModifyAssistantRequestToolResourcesCodeInterpreter),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ModifyAssistantRequestToolResourcesCodeInterpreter;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ModifyAssistantRequestToolResourcesCodeInterpreter?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ModifyAssistantRequestToolResourcesCodeInterpreter?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ModifyAssistantRequestToolResourcesFileSearch.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ModifyAssistantRequestToolResourcesFileSearch.g.cs
index e6dbdc9c..66c9ed2e 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ModifyAssistantRequestToolResourcesFileSearch.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ModifyAssistantRequestToolResourcesFileSearch.g.cs
@@ -77,5 +77,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ModifyAssistantRequestToolResourcesFileSearch?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ModifyAssistantRequestToolResourcesFileSearch),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ModifyAssistantRequestToolResourcesFileSearch;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ModifyAssistantRequestToolResourcesFileSearch?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ModifyAssistantRequestToolResourcesFileSearch?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ModifyMessageRequest.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ModifyMessageRequest.g.cs
index bacdb294..0946e63a 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ModifyMessageRequest.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ModifyMessageRequest.g.cs
@@ -77,5 +77,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ModifyMessageRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ModifyMessageRequest),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ModifyMessageRequest;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ModifyMessageRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ModifyMessageRequest?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ModifyMessageRequestMetadata.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ModifyMessageRequestMetadata.g.cs
index 29c4c22e..072813f3 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ModifyMessageRequestMetadata.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ModifyMessageRequestMetadata.g.cs
@@ -72,5 +72,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ModifyMessageRequestMetadata?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ModifyMessageRequestMetadata),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ModifyMessageRequestMetadata;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ModifyMessageRequestMetadata?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ModifyMessageRequestMetadata?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ModifyRunRequest.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ModifyRunRequest.g.cs
index 4c03cab0..4d9518c6 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ModifyRunRequest.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ModifyRunRequest.g.cs
@@ -77,5 +77,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ModifyRunRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ModifyRunRequest),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ModifyRunRequest;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ModifyRunRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ModifyRunRequest?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ModifyRunRequestMetadata.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ModifyRunRequestMetadata.g.cs
index 2cc62189..8c1e248f 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ModifyRunRequestMetadata.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ModifyRunRequestMetadata.g.cs
@@ -72,5 +72,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ModifyRunRequestMetadata?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ModifyRunRequestMetadata),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ModifyRunRequestMetadata;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ModifyRunRequestMetadata?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ModifyRunRequestMetadata?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ModifyThreadRequest.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ModifyThreadRequest.g.cs
index c7392c14..04a7f21f 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ModifyThreadRequest.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ModifyThreadRequest.g.cs
@@ -83,5 +83,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ModifyThreadRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ModifyThreadRequest),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ModifyThreadRequest;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ModifyThreadRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ModifyThreadRequest?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ModifyThreadRequestMetadata.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ModifyThreadRequestMetadata.g.cs
index c2a1a7c5..1fd36c93 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ModifyThreadRequestMetadata.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ModifyThreadRequestMetadata.g.cs
@@ -72,5 +72,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ModifyThreadRequestMetadata?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ModifyThreadRequestMetadata),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ModifyThreadRequestMetadata;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ModifyThreadRequestMetadata?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ModifyThreadRequestMetadata?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ModifyThreadRequestToolResources.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ModifyThreadRequestToolResources.g.cs
index 2b98e617..d969ba66 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ModifyThreadRequestToolResources.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ModifyThreadRequestToolResources.g.cs
@@ -83,5 +83,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ModifyThreadRequestToolResources?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ModifyThreadRequestToolResources),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ModifyThreadRequestToolResources;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ModifyThreadRequestToolResources?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ModifyThreadRequestToolResources?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ModifyThreadRequestToolResourcesCodeInterpreter.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ModifyThreadRequestToolResourcesCodeInterpreter.g.cs
index c5a7e8fc..9b836f08 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ModifyThreadRequestToolResourcesCodeInterpreter.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ModifyThreadRequestToolResourcesCodeInterpreter.g.cs
@@ -77,5 +77,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ModifyThreadRequestToolResourcesCodeInterpreter?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ModifyThreadRequestToolResourcesCodeInterpreter),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ModifyThreadRequestToolResourcesCodeInterpreter;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ModifyThreadRequestToolResourcesCodeInterpreter?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ModifyThreadRequestToolResourcesCodeInterpreter?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ModifyThreadRequestToolResourcesFileSearch.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ModifyThreadRequestToolResourcesFileSearch.g.cs
index d334dcd1..5728699a 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ModifyThreadRequestToolResourcesFileSearch.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ModifyThreadRequestToolResourcesFileSearch.g.cs
@@ -77,5 +77,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ModifyThreadRequestToolResourcesFileSearch?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ModifyThreadRequestToolResourcesFileSearch),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ModifyThreadRequestToolResourcesFileSearch;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ModifyThreadRequestToolResourcesFileSearch?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ModifyThreadRequestToolResourcesFileSearch?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.OpenAIFile.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.OpenAIFile.g.cs
index 437711ba..f53b5232 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.OpenAIFile.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.OpenAIFile.g.cs
@@ -130,5 +130,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.OpenAIFile?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.OpenAIFile),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.OpenAIFile;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.OpenAIFile?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.OpenAIFile?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.OtherChunkingStrategyResponseParam.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.OtherChunkingStrategyResponseParam.g.cs
index 3d9ae927..16257af7 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.OtherChunkingStrategyResponseParam.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.OtherChunkingStrategyResponseParam.g.cs
@@ -78,5 +78,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.OtherChunkingStrategyResponseParam?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.OtherChunkingStrategyResponseParam),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.OtherChunkingStrategyResponseParam;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.OtherChunkingStrategyResponseParam?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.OtherChunkingStrategyResponseParam?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.PredictionContent.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.PredictionContent.g.cs
index a5fab4eb..b51ffe0d 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.PredictionContent.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.PredictionContent.g.cs
@@ -92,5 +92,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.PredictionContent?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.PredictionContent),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.PredictionContent;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.PredictionContent?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.PredictionContent?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.Project.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.Project.g.cs
index 46f61932..1e1e7470 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.Project.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.Project.g.cs
@@ -115,5 +115,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.Project?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.Project),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.Project;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.Project?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.Project?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ProjectApiKey.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ProjectApiKey.g.cs
index c692db9f..c4168353 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ProjectApiKey.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ProjectApiKey.g.cs
@@ -114,5 +114,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ProjectApiKey?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ProjectApiKey),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ProjectApiKey;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ProjectApiKey?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ProjectApiKey?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ProjectApiKeyDeleteResponse.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ProjectApiKeyDeleteResponse.g.cs
index 945be8d6..8015ad7e 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ProjectApiKeyDeleteResponse.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ProjectApiKeyDeleteResponse.g.cs
@@ -92,5 +92,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ProjectApiKeyDeleteResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ProjectApiKeyDeleteResponse),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ProjectApiKeyDeleteResponse;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ProjectApiKeyDeleteResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ProjectApiKeyDeleteResponse?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ProjectApiKeyListResponse.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ProjectApiKeyListResponse.g.cs
index 1c6288f9..a027a079 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ProjectApiKeyListResponse.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ProjectApiKeyListResponse.g.cs
@@ -106,5 +106,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ProjectApiKeyListResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ProjectApiKeyListResponse),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ProjectApiKeyListResponse;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ProjectApiKeyListResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ProjectApiKeyListResponse?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ProjectApiKeyOwner.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ProjectApiKeyOwner.g.cs
index 334009d6..3012d469 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ProjectApiKeyOwner.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ProjectApiKeyOwner.g.cs
@@ -90,5 +90,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ProjectApiKeyOwner?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ProjectApiKeyOwner),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ProjectApiKeyOwner;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ProjectApiKeyOwner?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ProjectApiKeyOwner?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ProjectCreateRequest.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ProjectCreateRequest.g.cs
index 07a3c5ea..985d0349 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ProjectCreateRequest.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ProjectCreateRequest.g.cs
@@ -78,5 +78,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ProjectCreateRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ProjectCreateRequest),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ProjectCreateRequest;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ProjectCreateRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ProjectCreateRequest?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ProjectListResponse.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ProjectListResponse.g.cs
index df049dc6..7c8e23b2 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ProjectListResponse.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ProjectListResponse.g.cs
@@ -106,5 +106,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ProjectListResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ProjectListResponse),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ProjectListResponse;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ProjectListResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ProjectListResponse?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ProjectServiceAccount.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ProjectServiceAccount.g.cs
index bfb23e42..e7c17074 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ProjectServiceAccount.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ProjectServiceAccount.g.cs
@@ -108,5 +108,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ProjectServiceAccount?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ProjectServiceAccount),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ProjectServiceAccount;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ProjectServiceAccount?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ProjectServiceAccount?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ProjectServiceAccountApiKey.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ProjectServiceAccountApiKey.g.cs
index 9a6f9d67..0e4f28fe 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ProjectServiceAccountApiKey.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ProjectServiceAccountApiKey.g.cs
@@ -106,5 +106,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ProjectServiceAccountApiKey?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ProjectServiceAccountApiKey),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ProjectServiceAccountApiKey;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ProjectServiceAccountApiKey?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ProjectServiceAccountApiKey?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ProjectServiceAccountCreateRequest.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ProjectServiceAccountCreateRequest.g.cs
index 34e5dbb0..55b44ba9 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ProjectServiceAccountCreateRequest.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ProjectServiceAccountCreateRequest.g.cs
@@ -78,5 +78,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ProjectServiceAccountCreateRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ProjectServiceAccountCreateRequest),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ProjectServiceAccountCreateRequest;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ProjectServiceAccountCreateRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ProjectServiceAccountCreateRequest?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ProjectServiceAccountCreateResponse.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ProjectServiceAccountCreateResponse.g.cs
index 61a5d594..e19b448a 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ProjectServiceAccountCreateResponse.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ProjectServiceAccountCreateResponse.g.cs
@@ -113,5 +113,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ProjectServiceAccountCreateResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ProjectServiceAccountCreateResponse),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ProjectServiceAccountCreateResponse;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ProjectServiceAccountCreateResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ProjectServiceAccountCreateResponse?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ProjectServiceAccountDeleteResponse.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ProjectServiceAccountDeleteResponse.g.cs
index 0cad99dc..95434474 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ProjectServiceAccountDeleteResponse.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ProjectServiceAccountDeleteResponse.g.cs
@@ -92,5 +92,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ProjectServiceAccountDeleteResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ProjectServiceAccountDeleteResponse),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ProjectServiceAccountDeleteResponse;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ProjectServiceAccountDeleteResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ProjectServiceAccountDeleteResponse?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ProjectServiceAccountListResponse.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ProjectServiceAccountListResponse.g.cs
index 012c2f0d..019bf6fd 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ProjectServiceAccountListResponse.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ProjectServiceAccountListResponse.g.cs
@@ -106,5 +106,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ProjectServiceAccountListResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ProjectServiceAccountListResponse),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ProjectServiceAccountListResponse;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ProjectServiceAccountListResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ProjectServiceAccountListResponse?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ProjectUpdateRequest.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ProjectUpdateRequest.g.cs
index 2af0273f..bd48ea57 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ProjectUpdateRequest.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ProjectUpdateRequest.g.cs
@@ -78,5 +78,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ProjectUpdateRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ProjectUpdateRequest),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ProjectUpdateRequest;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ProjectUpdateRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ProjectUpdateRequest?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ProjectUser.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ProjectUser.g.cs
index 4733d098..43936911 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ProjectUser.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ProjectUser.g.cs
@@ -115,5 +115,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ProjectUser?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ProjectUser),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ProjectUser;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ProjectUser?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ProjectUser?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ProjectUserCreateRequest.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ProjectUserCreateRequest.g.cs
index 5d6f20d9..ff5d61dc 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ProjectUserCreateRequest.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ProjectUserCreateRequest.g.cs
@@ -86,5 +86,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ProjectUserCreateRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ProjectUserCreateRequest),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ProjectUserCreateRequest;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ProjectUserCreateRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ProjectUserCreateRequest?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ProjectUserDeleteResponse.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ProjectUserDeleteResponse.g.cs
index ac06ace5..e2e4483e 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ProjectUserDeleteResponse.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ProjectUserDeleteResponse.g.cs
@@ -92,5 +92,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ProjectUserDeleteResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ProjectUserDeleteResponse),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ProjectUserDeleteResponse;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ProjectUserDeleteResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ProjectUserDeleteResponse?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ProjectUserListResponse.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ProjectUserListResponse.g.cs
index 9f640927..97968cb6 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ProjectUserListResponse.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ProjectUserListResponse.g.cs
@@ -106,5 +106,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ProjectUserListResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ProjectUserListResponse),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ProjectUserListResponse;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ProjectUserListResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ProjectUserListResponse?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ProjectUserUpdateRequest.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ProjectUserUpdateRequest.g.cs
index 13f079bf..2c5cec0b 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ProjectUserUpdateRequest.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ProjectUserUpdateRequest.g.cs
@@ -79,5 +79,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ProjectUserUpdateRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ProjectUserUpdateRequest),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ProjectUserUpdateRequest;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ProjectUserUpdateRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ProjectUserUpdateRequest?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeClientEventConversationItemCreate.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeClientEventConversationItemCreate.g.cs
index 6ba9fe4f..c41e1767 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeClientEventConversationItemCreate.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeClientEventConversationItemCreate.g.cs
@@ -102,5 +102,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeClientEventConversationItemCreate?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeClientEventConversationItemCreate),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeClientEventConversationItemCreate;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeClientEventConversationItemCreate?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeClientEventConversationItemCreate?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeClientEventConversationItemDelete.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeClientEventConversationItemDelete.g.cs
index d3693416..995322c2 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeClientEventConversationItemDelete.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeClientEventConversationItemDelete.g.cs
@@ -91,5 +91,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeClientEventConversationItemDelete?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeClientEventConversationItemDelete),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeClientEventConversationItemDelete;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeClientEventConversationItemDelete?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeClientEventConversationItemDelete?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeClientEventConversationItemTruncate.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeClientEventConversationItemTruncate.g.cs
index 35c0f6ba..69981f0b 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeClientEventConversationItemTruncate.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeClientEventConversationItemTruncate.g.cs
@@ -107,5 +107,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeClientEventConversationItemTruncate?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeClientEventConversationItemTruncate),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeClientEventConversationItemTruncate;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeClientEventConversationItemTruncate?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeClientEventConversationItemTruncate?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeClientEventInputAudioBufferAppend.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeClientEventInputAudioBufferAppend.g.cs
index d50ac09a..3b079dc3 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeClientEventInputAudioBufferAppend.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeClientEventInputAudioBufferAppend.g.cs
@@ -92,5 +92,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeClientEventInputAudioBufferAppend?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeClientEventInputAudioBufferAppend),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeClientEventInputAudioBufferAppend;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeClientEventInputAudioBufferAppend?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeClientEventInputAudioBufferAppend?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeClientEventInputAudioBufferClear.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeClientEventInputAudioBufferClear.g.cs
index 5e281e43..c190b50b 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeClientEventInputAudioBufferClear.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeClientEventInputAudioBufferClear.g.cs
@@ -84,5 +84,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeClientEventInputAudioBufferClear?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeClientEventInputAudioBufferClear),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeClientEventInputAudioBufferClear;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeClientEventInputAudioBufferClear?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeClientEventInputAudioBufferClear?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeClientEventInputAudioBufferCommit.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeClientEventInputAudioBufferCommit.g.cs
index a40cfe0e..376f8602 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeClientEventInputAudioBufferCommit.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeClientEventInputAudioBufferCommit.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeClientEventInputAudioBufferCommit?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeClientEventInputAudioBufferCommit),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeClientEventInputAudioBufferCommit;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeClientEventInputAudioBufferCommit?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeClientEventInputAudioBufferCommit?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeClientEventResponseCancel.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeClientEventResponseCancel.g.cs
index 42ae7231..44dad1ab 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeClientEventResponseCancel.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeClientEventResponseCancel.g.cs
@@ -84,5 +84,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeClientEventResponseCancel?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeClientEventResponseCancel),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeClientEventResponseCancel;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeClientEventResponseCancel?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeClientEventResponseCancel?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeClientEventResponseCreate.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeClientEventResponseCreate.g.cs
index 0947f560..96244e3a 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeClientEventResponseCreate.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeClientEventResponseCreate.g.cs
@@ -94,5 +94,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeClientEventResponseCreate?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeClientEventResponseCreate),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeClientEventResponseCreate;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeClientEventResponseCreate?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeClientEventResponseCreate?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeClientEventSessionUpdate.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeClientEventSessionUpdate.g.cs
index d52c0e7e..7cf61622 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeClientEventSessionUpdate.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeClientEventSessionUpdate.g.cs
@@ -96,5 +96,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeClientEventSessionUpdate?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeClientEventSessionUpdate),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeClientEventSessionUpdate;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeClientEventSessionUpdate?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeClientEventSessionUpdate?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeContentPart.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeContentPart.g.cs
index ee0f106a..2fafec80 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeContentPart.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeContentPart.g.cs
@@ -98,5 +98,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeContentPart?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeContentPart),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeContentPart;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeContentPart?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeContentPart?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeConversation.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeConversation.g.cs
index d528e645..1ee796e9 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeConversation.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeConversation.g.cs
@@ -88,5 +88,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeConversation?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeConversation),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeConversation;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeConversation?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeConversation?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeConversationCreated.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeConversationCreated.g.cs
index f5e272e7..1dea8a46 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeConversationCreated.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeConversationCreated.g.cs
@@ -94,5 +94,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeConversationCreated?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeConversationCreated),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeConversationCreated;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeConversationCreated?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeConversationCreated?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeConversationItem.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeConversationItem.g.cs
index b90875c2..0aed968e 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeConversationItem.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeConversationItem.g.cs
@@ -120,5 +120,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeConversationItem?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeConversationItem),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeConversationItem;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeConversationItem?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeConversationItem?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeConversationItemContentItem.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeConversationItemContentItem.g.cs
index d951b9b8..826862a4 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeConversationItemContentItem.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeConversationItemContentItem.g.cs
@@ -122,5 +122,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeConversationItemContentItem?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeConversationItemContentItem),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeConversationItemContentItem;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeConversationItemContentItem?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeConversationItemContentItem?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeConversationItemCreate.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeConversationItemCreate.g.cs
index b6fbcae3..91d5ce74 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeConversationItemCreate.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeConversationItemCreate.g.cs
@@ -102,5 +102,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeConversationItemCreate?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeConversationItemCreate),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeConversationItemCreate;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeConversationItemCreate?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeConversationItemCreate?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeConversationItemCreated.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeConversationItemCreated.g.cs
index c355c06a..4174d01a 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeConversationItemCreated.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeConversationItemCreated.g.cs
@@ -103,5 +103,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeConversationItemCreated?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeConversationItemCreated),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeConversationItemCreated;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeConversationItemCreated?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeConversationItemCreated?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeConversationItemDelete.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeConversationItemDelete.g.cs
index 0684f38b..79ef7908 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeConversationItemDelete.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeConversationItemDelete.g.cs
@@ -93,5 +93,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeConversationItemDelete?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeConversationItemDelete),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeConversationItemDelete;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeConversationItemDelete?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeConversationItemDelete?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeConversationItemDeleted.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeConversationItemDeleted.g.cs
index 6784cc1d..b0ed5a55 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeConversationItemDeleted.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeConversationItemDeleted.g.cs
@@ -93,5 +93,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeConversationItemDeleted?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeConversationItemDeleted),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeConversationItemDeleted;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeConversationItemDeleted?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeConversationItemDeleted?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeConversationItemInputAudioTranscriptionCompleted.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeConversationItemInputAudioTranscriptionCompleted.g.cs
index 920e15ab..96d5c447 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeConversationItemInputAudioTranscriptionCompleted.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeConversationItemInputAudioTranscriptionCompleted.g.cs
@@ -107,5 +107,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeConversationItemInputAudioTranscriptionCompleted?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeConversationItemInputAudioTranscriptionCompleted),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeConversationItemInputAudioTranscriptionCompleted;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeConversationItemInputAudioTranscriptionCompleted?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeConversationItemInputAudioTranscriptionCompleted?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeConversationItemInputAudioTranscriptionFailed.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeConversationItemInputAudioTranscriptionFailed.g.cs
index c9fa9f63..83ce1730 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeConversationItemInputAudioTranscriptionFailed.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeConversationItemInputAudioTranscriptionFailed.g.cs
@@ -106,5 +106,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeConversationItemInputAudioTranscriptionFailed?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeConversationItemInputAudioTranscriptionFailed),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeConversationItemInputAudioTranscriptionFailed;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeConversationItemInputAudioTranscriptionFailed?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeConversationItemInputAudioTranscriptionFailed?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeConversationItemTruncate.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeConversationItemTruncate.g.cs
index 2675929b..331ff699 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeConversationItemTruncate.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeConversationItemTruncate.g.cs
@@ -107,5 +107,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeConversationItemTruncate?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeConversationItemTruncate),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeConversationItemTruncate;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeConversationItemTruncate?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeConversationItemTruncate?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeConversationItemTruncated.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeConversationItemTruncated.g.cs
index 7812249c..56283ecf 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeConversationItemTruncated.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeConversationItemTruncated.g.cs
@@ -107,5 +107,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeConversationItemTruncated?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeConversationItemTruncated),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeConversationItemTruncated;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeConversationItemTruncated?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeConversationItemTruncated?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeError.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeError.g.cs
index 0386e8f0..224c98ea 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeError.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeError.g.cs
@@ -92,5 +92,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeError?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeError),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeError;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeError?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeError?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeErrorDetails.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeErrorDetails.g.cs
index 2f391159..92c62137 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeErrorDetails.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeErrorDetails.g.cs
@@ -105,5 +105,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeErrorDetails?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeErrorDetails),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeErrorDetails;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeErrorDetails?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeErrorDetails?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeInputAudioBufferAppend.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeInputAudioBufferAppend.g.cs
index b98db0f0..5b20bce9 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeInputAudioBufferAppend.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeInputAudioBufferAppend.g.cs
@@ -93,5 +93,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeInputAudioBufferAppend?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeInputAudioBufferAppend),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeInputAudioBufferAppend;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeInputAudioBufferAppend?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeInputAudioBufferAppend?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeInputAudioBufferClear.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeInputAudioBufferClear.g.cs
index b7002e61..db2e46c6 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeInputAudioBufferClear.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeInputAudioBufferClear.g.cs
@@ -86,5 +86,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeInputAudioBufferClear?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeInputAudioBufferClear),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeInputAudioBufferClear;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeInputAudioBufferClear?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeInputAudioBufferClear?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeInputAudioBufferCleared.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeInputAudioBufferCleared.g.cs
index 1362c1ea..53b369ef 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeInputAudioBufferCleared.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeInputAudioBufferCleared.g.cs
@@ -86,5 +86,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeInputAudioBufferCleared?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeInputAudioBufferCleared),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeInputAudioBufferCleared;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeInputAudioBufferCleared?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeInputAudioBufferCleared?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeInputAudioBufferCommit.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeInputAudioBufferCommit.g.cs
index 88e88938..aebc3bba 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeInputAudioBufferCommit.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeInputAudioBufferCommit.g.cs
@@ -86,5 +86,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeInputAudioBufferCommit?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeInputAudioBufferCommit),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeInputAudioBufferCommit;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeInputAudioBufferCommit?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeInputAudioBufferCommit?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeInputAudioBufferCommitted.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeInputAudioBufferCommitted.g.cs
index 7a579caa..63905df8 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeInputAudioBufferCommitted.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeInputAudioBufferCommitted.g.cs
@@ -100,5 +100,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeInputAudioBufferCommitted?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeInputAudioBufferCommitted),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeInputAudioBufferCommitted;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeInputAudioBufferCommitted?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeInputAudioBufferCommitted?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeInputAudioBufferSpeechStarted.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeInputAudioBufferSpeechStarted.g.cs
index d5773102..ef03e395 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeInputAudioBufferSpeechStarted.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeInputAudioBufferSpeechStarted.g.cs
@@ -100,5 +100,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeInputAudioBufferSpeechStarted?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeInputAudioBufferSpeechStarted),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeInputAudioBufferSpeechStarted;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeInputAudioBufferSpeechStarted?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeInputAudioBufferSpeechStarted?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeInputAudioBufferSpeechStopped.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeInputAudioBufferSpeechStopped.g.cs
index a3ab444a..a68140d8 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeInputAudioBufferSpeechStopped.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeInputAudioBufferSpeechStopped.g.cs
@@ -100,5 +100,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeInputAudioBufferSpeechStopped?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeInputAudioBufferSpeechStopped),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeInputAudioBufferSpeechStopped;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeInputAudioBufferSpeechStopped?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeInputAudioBufferSpeechStopped?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeRateLimitsUpdated.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeRateLimitsUpdated.g.cs
index e0dfe2e6..45f3de0a 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeRateLimitsUpdated.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeRateLimitsUpdated.g.cs
@@ -92,5 +92,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeRateLimitsUpdated?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeRateLimitsUpdated),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeRateLimitsUpdated;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeRateLimitsUpdated?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeRateLimitsUpdated?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeRateLimitsUpdatedRateLimit.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeRateLimitsUpdatedRateLimit.g.cs
index 9043f9df..950dc523 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeRateLimitsUpdatedRateLimit.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeRateLimitsUpdatedRateLimit.g.cs
@@ -100,5 +100,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeRateLimitsUpdatedRateLimit?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeRateLimitsUpdatedRateLimit),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeRateLimitsUpdatedRateLimit;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeRateLimitsUpdatedRateLimit?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeRateLimitsUpdatedRateLimit?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponse.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponse.g.cs
index b92991c7..cdfda149 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponse.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponse.g.cs
@@ -112,5 +112,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeResponse),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeResponse;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeResponse?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseAudioDelta.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseAudioDelta.g.cs
index 44aab6b5..dc0e907c 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseAudioDelta.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseAudioDelta.g.cs
@@ -121,5 +121,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeResponseAudioDelta?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeResponseAudioDelta),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeResponseAudioDelta;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeResponseAudioDelta?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeResponseAudioDelta?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseAudioDone.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseAudioDone.g.cs
index e9adda84..9578fd6d 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseAudioDone.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseAudioDone.g.cs
@@ -114,5 +114,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeResponseAudioDone?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeResponseAudioDone),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeResponseAudioDone;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeResponseAudioDone?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeResponseAudioDone?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseAudioTranscriptDelta.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseAudioTranscriptDelta.g.cs
index a729b8fc..7f445f1b 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseAudioTranscriptDelta.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseAudioTranscriptDelta.g.cs
@@ -121,5 +121,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeResponseAudioTranscriptDelta?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeResponseAudioTranscriptDelta),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeResponseAudioTranscriptDelta;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeResponseAudioTranscriptDelta?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeResponseAudioTranscriptDelta?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseAudioTranscriptDone.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseAudioTranscriptDone.g.cs
index 10b294ed..c67c298a 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseAudioTranscriptDone.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseAudioTranscriptDone.g.cs
@@ -121,5 +121,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeResponseAudioTranscriptDone?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeResponseAudioTranscriptDone),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeResponseAudioTranscriptDone;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeResponseAudioTranscriptDone?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeResponseAudioTranscriptDone?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseCancel.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseCancel.g.cs
index 5d1fbf71..4ed0624b 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseCancel.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseCancel.g.cs
@@ -86,5 +86,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeResponseCancel?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeResponseCancel),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeResponseCancel;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeResponseCancel?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeResponseCancel?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseContentPartAdded.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseContentPartAdded.g.cs
index a1bc80bc..a3d4422b 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseContentPartAdded.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseContentPartAdded.g.cs
@@ -120,5 +120,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeResponseContentPartAdded?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeResponseContentPartAdded),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeResponseContentPartAdded;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeResponseContentPartAdded?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeResponseContentPartAdded?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseContentPartDone.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseContentPartDone.g.cs
index d5a1575a..1ad28470 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseContentPartDone.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseContentPartDone.g.cs
@@ -120,5 +120,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeResponseContentPartDone?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeResponseContentPartDone),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeResponseContentPartDone;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeResponseContentPartDone?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeResponseContentPartDone?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseCreate.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseCreate.g.cs
index 21750ccc..0ed1a772 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseCreate.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseCreate.g.cs
@@ -90,5 +90,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeResponseCreate?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeResponseCreate),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeResponseCreate;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeResponseCreate?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeResponseCreate?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseCreateResponse.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseCreateResponse.g.cs
index f309670a..55e284fd 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseCreateResponse.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseCreateResponse.g.cs
@@ -127,5 +127,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeResponseCreateResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeResponseCreateResponse),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeResponseCreateResponse;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeResponseCreateResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeResponseCreateResponse?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseCreateResponseTool.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseCreateResponseTool.g.cs
index b39d2fa3..2bb0cd69 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseCreateResponseTool.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseCreateResponseTool.g.cs
@@ -95,5 +95,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeResponseCreateResponseTool?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeResponseCreateResponseTool),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeResponseCreateResponseTool;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeResponseCreateResponseTool?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeResponseCreateResponseTool?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseCreateResponseToolParameters.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseCreateResponseToolParameters.g.cs
index 5fb4b325..30292ec6 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseCreateResponseToolParameters.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseCreateResponseToolParameters.g.cs
@@ -72,5 +72,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeResponseCreateResponseToolParameters?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeResponseCreateResponseToolParameters),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeResponseCreateResponseToolParameters;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeResponseCreateResponseToolParameters?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeResponseCreateResponseToolParameters?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseCreated.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseCreated.g.cs
index 4407f083..d1ae1798 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseCreated.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseCreated.g.cs
@@ -92,5 +92,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeResponseCreated?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeResponseCreated),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeResponseCreated;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeResponseCreated?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeResponseCreated?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseDone.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseDone.g.cs
index 1bbb0726..2d179979 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseDone.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseDone.g.cs
@@ -92,5 +92,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeResponseDone?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeResponseDone),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeResponseDone;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeResponseDone?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeResponseDone?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseFunctionCallArgumentsDelta.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseFunctionCallArgumentsDelta.g.cs
index eb21e1c4..1b945150 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseFunctionCallArgumentsDelta.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseFunctionCallArgumentsDelta.g.cs
@@ -121,5 +121,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeResponseFunctionCallArgumentsDelta?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeResponseFunctionCallArgumentsDelta),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeResponseFunctionCallArgumentsDelta;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeResponseFunctionCallArgumentsDelta?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeResponseFunctionCallArgumentsDelta?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseFunctionCallArgumentsDone.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseFunctionCallArgumentsDone.g.cs
index 73d70da8..22e1c522 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseFunctionCallArgumentsDone.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseFunctionCallArgumentsDone.g.cs
@@ -121,5 +121,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeResponseFunctionCallArgumentsDone?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeResponseFunctionCallArgumentsDone),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeResponseFunctionCallArgumentsDone;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeResponseFunctionCallArgumentsDone?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeResponseFunctionCallArgumentsDone?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseOutputItemAdded.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseOutputItemAdded.g.cs
index 1ecfdffd..860b9b18 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseOutputItemAdded.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseOutputItemAdded.g.cs
@@ -110,5 +110,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeResponseOutputItemAdded?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeResponseOutputItemAdded),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeResponseOutputItemAdded;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeResponseOutputItemAdded?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeResponseOutputItemAdded?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseOutputItemDone.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseOutputItemDone.g.cs
index a12ecb00..c5e11c91 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseOutputItemDone.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseOutputItemDone.g.cs
@@ -110,5 +110,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeResponseOutputItemDone?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeResponseOutputItemDone),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeResponseOutputItemDone;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeResponseOutputItemDone?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeResponseOutputItemDone?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseStatusDetails.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseStatusDetails.g.cs
index f92a0b4f..737a13b1 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseStatusDetails.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseStatusDetails.g.cs
@@ -72,5 +72,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeResponseStatusDetails?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeResponseStatusDetails),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeResponseStatusDetails;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeResponseStatusDetails?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeResponseStatusDetails?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseTextDelta.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseTextDelta.g.cs
index 51b6aa7c..e25ef4a0 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseTextDelta.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseTextDelta.g.cs
@@ -121,5 +121,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeResponseTextDelta?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeResponseTextDelta),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeResponseTextDelta;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeResponseTextDelta?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeResponseTextDelta?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseTextDone.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseTextDone.g.cs
index cac4ec6f..5d7aac2c 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseTextDone.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseTextDone.g.cs
@@ -121,5 +121,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeResponseTextDone?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeResponseTextDone),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeResponseTextDone;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeResponseTextDone?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeResponseTextDone?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseUsage.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseUsage.g.cs
index b184eabd..b3af231a 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseUsage.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeResponseUsage.g.cs
@@ -92,5 +92,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeResponseUsage?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeResponseUsage),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeResponseUsage;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeResponseUsage?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeResponseUsage?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEvent.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEvent.g.cs
index 7b3ad46f..6338e83d 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEvent.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEvent.g.cs
@@ -1602,5 +1602,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEvent?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeServerEvent),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeServerEvent?;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEvent?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeServerEvent?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventBase.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventBase.g.cs
index fd7b8a3f..8510fc49 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventBase.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventBase.g.cs
@@ -86,5 +86,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventBase?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeServerEventBase),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeServerEventBase;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventBase?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeServerEventBase?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventConversationCreated.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventConversationCreated.g.cs
index aba06cd0..bd6b677f 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventConversationCreated.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventConversationCreated.g.cs
@@ -92,5 +92,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventConversationCreated?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeServerEventConversationCreated),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeServerEventConversationCreated;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventConversationCreated?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeServerEventConversationCreated?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventConversationCreatedConversation.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventConversationCreatedConversation.g.cs
index 148f9eb9..c4fa6a3b 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventConversationCreatedConversation.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventConversationCreatedConversation.g.cs
@@ -83,5 +83,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventConversationCreatedConversation?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeServerEventConversationCreatedConversation),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeServerEventConversationCreatedConversation;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventConversationCreatedConversation?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeServerEventConversationCreatedConversation?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventConversationItemCreated.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventConversationItemCreated.g.cs
index 99d33fd1..0b69bf90 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventConversationItemCreated.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventConversationItemCreated.g.cs
@@ -106,5 +106,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventConversationItemCreated?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeServerEventConversationItemCreated),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeServerEventConversationItemCreated;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventConversationItemCreated?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeServerEventConversationItemCreated?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventConversationItemDeleted.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventConversationItemDeleted.g.cs
index 554f8112..2417a0b8 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventConversationItemDeleted.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventConversationItemDeleted.g.cs
@@ -92,5 +92,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventConversationItemDeleted?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeServerEventConversationItemDeleted),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeServerEventConversationItemDeleted;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventConversationItemDeleted?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeServerEventConversationItemDeleted?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventConversationItemInputAudioTranscriptionCompleted.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventConversationItemInputAudioTranscriptionCompleted.g.cs
index 0e004d08..9c54b961 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventConversationItemInputAudioTranscriptionCompleted.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventConversationItemInputAudioTranscriptionCompleted.g.cs
@@ -107,5 +107,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventConversationItemInputAudioTranscriptionCompleted?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeServerEventConversationItemInputAudioTranscriptionCompleted),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeServerEventConversationItemInputAudioTranscriptionCompleted;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventConversationItemInputAudioTranscriptionCompleted?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeServerEventConversationItemInputAudioTranscriptionCompleted?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventConversationItemInputAudioTranscriptionFailed.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventConversationItemInputAudioTranscriptionFailed.g.cs
index e8e88bde..59ef9db1 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventConversationItemInputAudioTranscriptionFailed.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventConversationItemInputAudioTranscriptionFailed.g.cs
@@ -106,5 +106,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventConversationItemInputAudioTranscriptionFailed?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeServerEventConversationItemInputAudioTranscriptionFailed),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeServerEventConversationItemInputAudioTranscriptionFailed;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventConversationItemInputAudioTranscriptionFailed?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeServerEventConversationItemInputAudioTranscriptionFailed?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventConversationItemInputAudioTranscriptionFailedError.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventConversationItemInputAudioTranscriptionFailedError.g.cs
index 7730b202..42985b4a 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventConversationItemInputAudioTranscriptionFailedError.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventConversationItemInputAudioTranscriptionFailedError.g.cs
@@ -95,5 +95,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventConversationItemInputAudioTranscriptionFailedError?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeServerEventConversationItemInputAudioTranscriptionFailedError),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeServerEventConversationItemInputAudioTranscriptionFailedError;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventConversationItemInputAudioTranscriptionFailedError?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeServerEventConversationItemInputAudioTranscriptionFailedError?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventConversationItemTruncated.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventConversationItemTruncated.g.cs
index 866480a7..8bc4c0cb 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventConversationItemTruncated.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventConversationItemTruncated.g.cs
@@ -107,5 +107,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventConversationItemTruncated?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeServerEventConversationItemTruncated),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeServerEventConversationItemTruncated;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventConversationItemTruncated?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeServerEventConversationItemTruncated?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventDiscriminator.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventDiscriminator.g.cs
index 57391750..eb5ad93c 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventDiscriminator.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventDiscriminator.g.cs
@@ -78,5 +78,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventDiscriminator?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeServerEventDiscriminator),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeServerEventDiscriminator;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventDiscriminator?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeServerEventDiscriminator?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventError.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventError.g.cs
index 3eb0c4da..06f55aa9 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventError.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventError.g.cs
@@ -92,5 +92,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventError?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeServerEventError),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeServerEventError;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventError?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeServerEventError?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventErrorError.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventErrorError.g.cs
index c92c8580..78ff3c34 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventErrorError.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventErrorError.g.cs
@@ -101,5 +101,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventErrorError?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeServerEventErrorError),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeServerEventErrorError;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventErrorError?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeServerEventErrorError?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventInputAudioBufferCleared.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventInputAudioBufferCleared.g.cs
index 059557a0..896e5fee 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventInputAudioBufferCleared.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventInputAudioBufferCleared.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventInputAudioBufferCleared?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeServerEventInputAudioBufferCleared),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeServerEventInputAudioBufferCleared;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventInputAudioBufferCleared?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeServerEventInputAudioBufferCleared?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventInputAudioBufferCommitted.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventInputAudioBufferCommitted.g.cs
index 594c3149..bb44127e 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventInputAudioBufferCommitted.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventInputAudioBufferCommitted.g.cs
@@ -99,5 +99,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventInputAudioBufferCommitted?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeServerEventInputAudioBufferCommitted),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeServerEventInputAudioBufferCommitted;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventInputAudioBufferCommitted?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeServerEventInputAudioBufferCommitted?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventInputAudioBufferSpeechStarted.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventInputAudioBufferSpeechStarted.g.cs
index a3105b44..95438f2b 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventInputAudioBufferSpeechStarted.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventInputAudioBufferSpeechStarted.g.cs
@@ -99,5 +99,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventInputAudioBufferSpeechStarted?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeServerEventInputAudioBufferSpeechStarted),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeServerEventInputAudioBufferSpeechStarted;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventInputAudioBufferSpeechStarted?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeServerEventInputAudioBufferSpeechStarted?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventInputAudioBufferSpeechStopped.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventInputAudioBufferSpeechStopped.g.cs
index 3beaee59..21c346ef 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventInputAudioBufferSpeechStopped.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventInputAudioBufferSpeechStopped.g.cs
@@ -99,5 +99,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventInputAudioBufferSpeechStopped?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeServerEventInputAudioBufferSpeechStopped),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeServerEventInputAudioBufferSpeechStopped;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventInputAudioBufferSpeechStopped?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeServerEventInputAudioBufferSpeechStopped?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventRateLimitsUpdated.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventRateLimitsUpdated.g.cs
index 8414f2d3..1e539cb8 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventRateLimitsUpdated.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventRateLimitsUpdated.g.cs
@@ -92,5 +92,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventRateLimitsUpdated?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeServerEventRateLimitsUpdated),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeServerEventRateLimitsUpdated;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventRateLimitsUpdated?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeServerEventRateLimitsUpdated?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventRateLimitsUpdatedRateLimit.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventRateLimitsUpdatedRateLimit.g.cs
index a6bf5b9e..ae5d8662 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventRateLimitsUpdatedRateLimit.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventRateLimitsUpdatedRateLimit.g.cs
@@ -95,5 +95,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventRateLimitsUpdatedRateLimit?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeServerEventRateLimitsUpdatedRateLimit),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeServerEventRateLimitsUpdatedRateLimit;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventRateLimitsUpdatedRateLimit?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeServerEventRateLimitsUpdatedRateLimit?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventResponseAudioDelta.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventResponseAudioDelta.g.cs
index 781fc670..ca87b685 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventResponseAudioDelta.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventResponseAudioDelta.g.cs
@@ -120,5 +120,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventResponseAudioDelta?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeServerEventResponseAudioDelta),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeServerEventResponseAudioDelta;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventResponseAudioDelta?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeServerEventResponseAudioDelta?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventResponseAudioDone.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventResponseAudioDone.g.cs
index 8320df39..6a5de6ec 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventResponseAudioDone.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventResponseAudioDone.g.cs
@@ -113,5 +113,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventResponseAudioDone?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeServerEventResponseAudioDone),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeServerEventResponseAudioDone;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventResponseAudioDone?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeServerEventResponseAudioDone?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventResponseAudioTranscriptDelta.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventResponseAudioTranscriptDelta.g.cs
index b40e9d0e..6c7bd752 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventResponseAudioTranscriptDelta.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventResponseAudioTranscriptDelta.g.cs
@@ -120,5 +120,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventResponseAudioTranscriptDelta?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeServerEventResponseAudioTranscriptDelta),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeServerEventResponseAudioTranscriptDelta;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventResponseAudioTranscriptDelta?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeServerEventResponseAudioTranscriptDelta?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventResponseAudioTranscriptDone.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventResponseAudioTranscriptDone.g.cs
index 1a06ff35..4f4e37fb 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventResponseAudioTranscriptDone.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventResponseAudioTranscriptDone.g.cs
@@ -120,5 +120,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventResponseAudioTranscriptDone?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeServerEventResponseAudioTranscriptDone),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeServerEventResponseAudioTranscriptDone;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventResponseAudioTranscriptDone?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeServerEventResponseAudioTranscriptDone?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventResponseContentPartAdded.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventResponseContentPartAdded.g.cs
index 9df1ac9c..436c8aea 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventResponseContentPartAdded.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventResponseContentPartAdded.g.cs
@@ -120,5 +120,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventResponseContentPartAdded?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeServerEventResponseContentPartAdded),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeServerEventResponseContentPartAdded;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventResponseContentPartAdded?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeServerEventResponseContentPartAdded?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventResponseContentPartAddedPart.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventResponseContentPartAddedPart.g.cs
index 4bcc2d25..086e538d 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventResponseContentPartAddedPart.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventResponseContentPartAddedPart.g.cs
@@ -95,5 +95,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventResponseContentPartAddedPart?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeServerEventResponseContentPartAddedPart),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeServerEventResponseContentPartAddedPart;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventResponseContentPartAddedPart?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeServerEventResponseContentPartAddedPart?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventResponseContentPartDone.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventResponseContentPartDone.g.cs
index 8a43b866..2be4b2bd 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventResponseContentPartDone.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventResponseContentPartDone.g.cs
@@ -120,5 +120,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventResponseContentPartDone?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeServerEventResponseContentPartDone),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeServerEventResponseContentPartDone;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventResponseContentPartDone?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeServerEventResponseContentPartDone?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventResponseContentPartDonePart.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventResponseContentPartDonePart.g.cs
index 8987bafe..eda42c2b 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventResponseContentPartDonePart.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventResponseContentPartDonePart.g.cs
@@ -95,5 +95,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventResponseContentPartDonePart?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeServerEventResponseContentPartDonePart),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeServerEventResponseContentPartDonePart;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventResponseContentPartDonePart?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeServerEventResponseContentPartDonePart?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventResponseCreated.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventResponseCreated.g.cs
index 08de7b3d..d79651c7 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventResponseCreated.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventResponseCreated.g.cs
@@ -92,5 +92,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventResponseCreated?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeServerEventResponseCreated),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeServerEventResponseCreated;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventResponseCreated?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeServerEventResponseCreated?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventResponseDone.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventResponseDone.g.cs
index ab062d9a..5ff3c31b 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventResponseDone.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventResponseDone.g.cs
@@ -92,5 +92,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventResponseDone?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeServerEventResponseDone),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeServerEventResponseDone;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventResponseDone?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeServerEventResponseDone?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventResponseFunctionCallArgumentsDelta.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventResponseFunctionCallArgumentsDelta.g.cs
index 35793c47..6df36480 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventResponseFunctionCallArgumentsDelta.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventResponseFunctionCallArgumentsDelta.g.cs
@@ -120,5 +120,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventResponseFunctionCallArgumentsDelta?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeServerEventResponseFunctionCallArgumentsDelta),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeServerEventResponseFunctionCallArgumentsDelta;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventResponseFunctionCallArgumentsDelta?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeServerEventResponseFunctionCallArgumentsDelta?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventResponseFunctionCallArgumentsDone.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventResponseFunctionCallArgumentsDone.g.cs
index ab1abb7f..446df361 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventResponseFunctionCallArgumentsDone.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventResponseFunctionCallArgumentsDone.g.cs
@@ -120,5 +120,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventResponseFunctionCallArgumentsDone?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeServerEventResponseFunctionCallArgumentsDone),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeServerEventResponseFunctionCallArgumentsDone;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventResponseFunctionCallArgumentsDone?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeServerEventResponseFunctionCallArgumentsDone?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventResponseOutputItemAdded.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventResponseOutputItemAdded.g.cs
index 8ff6b99f..a03d0770 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventResponseOutputItemAdded.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventResponseOutputItemAdded.g.cs
@@ -110,5 +110,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventResponseOutputItemAdded?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeServerEventResponseOutputItemAdded),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeServerEventResponseOutputItemAdded;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventResponseOutputItemAdded?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeServerEventResponseOutputItemAdded?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventResponseOutputItemDone.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventResponseOutputItemDone.g.cs
index 7f1c53e2..3ceecaaa 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventResponseOutputItemDone.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventResponseOutputItemDone.g.cs
@@ -110,5 +110,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventResponseOutputItemDone?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeServerEventResponseOutputItemDone),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeServerEventResponseOutputItemDone;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventResponseOutputItemDone?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeServerEventResponseOutputItemDone?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventResponseTextDelta.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventResponseTextDelta.g.cs
index ba68a9ed..35bfae62 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventResponseTextDelta.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventResponseTextDelta.g.cs
@@ -120,5 +120,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventResponseTextDelta?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeServerEventResponseTextDelta),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeServerEventResponseTextDelta;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventResponseTextDelta?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeServerEventResponseTextDelta?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventResponseTextDone.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventResponseTextDone.g.cs
index 345b17ad..972e5af1 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventResponseTextDone.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventResponseTextDone.g.cs
@@ -120,5 +120,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventResponseTextDone?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeServerEventResponseTextDone),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeServerEventResponseTextDone;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventResponseTextDone?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeServerEventResponseTextDone?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventSessionCreated.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventSessionCreated.g.cs
index 7c6cc062..2ddf6723 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventSessionCreated.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventSessionCreated.g.cs
@@ -97,5 +97,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventSessionCreated?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeServerEventSessionCreated),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeServerEventSessionCreated;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventSessionCreated?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeServerEventSessionCreated?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventSessionUpdated.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventSessionUpdated.g.cs
index ad96db9d..815c5697 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventSessionUpdated.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeServerEventSessionUpdated.g.cs
@@ -97,5 +97,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventSessionUpdated?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeServerEventSessionUpdated),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeServerEventSessionUpdated;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeServerEventSessionUpdated?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeServerEventSessionUpdated?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeSession.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeSession.g.cs
index eea43b72..ccb2e8ee 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeSession.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeSession.g.cs
@@ -177,5 +177,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeSession?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeSession),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeSession;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeSession?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeSession?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeSessionCreated.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeSessionCreated.g.cs
index ec21a260..0bff6353 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeSessionCreated.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeSessionCreated.g.cs
@@ -97,5 +97,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeSessionCreated?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeSessionCreated),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeSessionCreated;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeSessionCreated?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeSessionCreated?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeSessionInputAudioTranscription.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeSessionInputAudioTranscription.g.cs
index 4fb743eb..4d816335 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeSessionInputAudioTranscription.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeSessionInputAudioTranscription.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeSessionInputAudioTranscription?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeSessionInputAudioTranscription),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeSessionInputAudioTranscription;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeSessionInputAudioTranscription?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeSessionInputAudioTranscription?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeSessionTool.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeSessionTool.g.cs
index f5460eca..d62d7f94 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeSessionTool.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeSessionTool.g.cs
@@ -98,5 +98,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeSessionTool?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeSessionTool),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeSessionTool;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeSessionTool?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeSessionTool?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeSessionToolParameters.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeSessionToolParameters.g.cs
index 92bcab8e..9630f30a 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeSessionToolParameters.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeSessionToolParameters.g.cs
@@ -72,5 +72,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeSessionToolParameters?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeSessionToolParameters),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeSessionToolParameters;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeSessionToolParameters?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeSessionToolParameters?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeSessionTurnDetection.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeSessionTurnDetection.g.cs
index 863b3a8d..f682abab 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeSessionTurnDetection.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeSessionTurnDetection.g.cs
@@ -100,5 +100,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeSessionTurnDetection?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeSessionTurnDetection),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeSessionTurnDetection;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeSessionTurnDetection?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeSessionTurnDetection?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeSessionUpdate.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeSessionUpdate.g.cs
index 3637bfe1..ce582e57 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeSessionUpdate.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeSessionUpdate.g.cs
@@ -97,5 +97,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeSessionUpdate?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeSessionUpdate),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeSessionUpdate;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeSessionUpdate?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeSessionUpdate?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeSessionUpdated.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeSessionUpdated.g.cs
index b6728e33..29a80a6d 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeSessionUpdated.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RealtimeSessionUpdated.g.cs
@@ -97,5 +97,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeSessionUpdated?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RealtimeSessionUpdated),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RealtimeSessionUpdated;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RealtimeSessionUpdated?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RealtimeSessionUpdated?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ResponseFormat.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ResponseFormat.g.cs
index f1c1c9c9..e1106042 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ResponseFormat.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ResponseFormat.g.cs
@@ -330,5 +330,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ResponseFormat?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ResponseFormat),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ResponseFormat?;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ResponseFormat?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ResponseFormat?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ResponseFormatJsonObject.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ResponseFormatJsonObject.g.cs
index fd894d60..02795f21 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ResponseFormatJsonObject.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ResponseFormatJsonObject.g.cs
@@ -78,5 +78,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ResponseFormatJsonObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ResponseFormatJsonObject),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ResponseFormatJsonObject;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ResponseFormatJsonObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ResponseFormatJsonObject?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ResponseFormatJsonSchema.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ResponseFormatJsonSchema.g.cs
index 5df32c96..0aef3b89 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ResponseFormatJsonSchema.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ResponseFormatJsonSchema.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ResponseFormatJsonSchema?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ResponseFormatJsonSchema),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ResponseFormatJsonSchema;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ResponseFormatJsonSchema?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ResponseFormatJsonSchema?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ResponseFormatJsonSchemaJsonSchema.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ResponseFormatJsonSchemaJsonSchema.g.cs
index b5e5417a..653845f4 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ResponseFormatJsonSchemaJsonSchema.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ResponseFormatJsonSchemaJsonSchema.g.cs
@@ -97,5 +97,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ResponseFormatJsonSchemaJsonSchema?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ResponseFormatJsonSchemaJsonSchema),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ResponseFormatJsonSchemaJsonSchema;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ResponseFormatJsonSchemaJsonSchema?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ResponseFormatJsonSchemaJsonSchema?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ResponseFormatJsonSchemaSchema.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ResponseFormatJsonSchemaSchema.g.cs
index 325dfb2d..3600ccf2 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ResponseFormatJsonSchemaSchema.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ResponseFormatJsonSchemaSchema.g.cs
@@ -72,5 +72,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ResponseFormatJsonSchemaSchema?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ResponseFormatJsonSchemaSchema),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ResponseFormatJsonSchemaSchema;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ResponseFormatJsonSchemaSchema?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ResponseFormatJsonSchemaSchema?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ResponseFormatText.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ResponseFormatText.g.cs
index ee155a62..e675a6d6 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ResponseFormatText.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ResponseFormatText.g.cs
@@ -78,5 +78,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ResponseFormatText?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ResponseFormatText),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ResponseFormatText;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ResponseFormatText?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ResponseFormatText?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RunCompletionUsage.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RunCompletionUsage.g.cs
index b8230cbc..2919c77a 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RunCompletionUsage.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RunCompletionUsage.g.cs
@@ -92,5 +92,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RunCompletionUsage?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RunCompletionUsage),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RunCompletionUsage;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RunCompletionUsage?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RunCompletionUsage?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RunObject.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RunObject.g.cs
index 831c8b52..8eb11501 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RunObject.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RunObject.g.cs
@@ -274,5 +274,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RunObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RunObject),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RunObject;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RunObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RunObject?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RunObjectIncompleteDetails.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RunObjectIncompleteDetails.g.cs
index d3225c3d..57bc9d1b 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RunObjectIncompleteDetails.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RunObjectIncompleteDetails.g.cs
@@ -78,5 +78,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RunObjectIncompleteDetails?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RunObjectIncompleteDetails),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RunObjectIncompleteDetails;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RunObjectIncompleteDetails?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RunObjectIncompleteDetails?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RunObjectLastError.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RunObjectLastError.g.cs
index a823706a..94463610 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RunObjectLastError.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RunObjectLastError.g.cs
@@ -86,5 +86,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RunObjectLastError?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RunObjectLastError),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RunObjectLastError;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RunObjectLastError?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RunObjectLastError?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RunObjectMetadata.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RunObjectMetadata.g.cs
index 20940341..3fe56e50 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RunObjectMetadata.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RunObjectMetadata.g.cs
@@ -72,5 +72,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RunObjectMetadata?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RunObjectMetadata),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RunObjectMetadata;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RunObjectMetadata?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RunObjectMetadata?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RunObjectRequiredAction.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RunObjectRequiredAction.g.cs
index 51a2d9ef..1ae7eaaf 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RunObjectRequiredAction.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RunObjectRequiredAction.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RunObjectRequiredAction?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RunObjectRequiredAction),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RunObjectRequiredAction;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RunObjectRequiredAction?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RunObjectRequiredAction?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RunObjectRequiredActionSubmitToolOutputs.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RunObjectRequiredActionSubmitToolOutputs.g.cs
index cfd9c1b7..2422bf91 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RunObjectRequiredActionSubmitToolOutputs.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RunObjectRequiredActionSubmitToolOutputs.g.cs
@@ -78,5 +78,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RunObjectRequiredActionSubmitToolOutputs?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RunObjectRequiredActionSubmitToolOutputs),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RunObjectRequiredActionSubmitToolOutputs;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RunObjectRequiredActionSubmitToolOutputs?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RunObjectRequiredActionSubmitToolOutputs?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RunObjectToolDiscriminator.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RunObjectToolDiscriminator.g.cs
index 9124af2f..886527d3 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RunObjectToolDiscriminator.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RunObjectToolDiscriminator.g.cs
@@ -78,5 +78,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RunObjectToolDiscriminator?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RunObjectToolDiscriminator),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RunObjectToolDiscriminator;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RunObjectToolDiscriminator?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RunObjectToolDiscriminator?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepCompletionUsage.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepCompletionUsage.g.cs
index eaad1595..f2e32082 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepCompletionUsage.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepCompletionUsage.g.cs
@@ -92,5 +92,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepCompletionUsage?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RunStepCompletionUsage),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RunStepCompletionUsage;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepCompletionUsage?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RunStepCompletionUsage?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaObject.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaObject.g.cs
index 2f7c2d73..ffcf6156 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaObject.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaObject.g.cs
@@ -92,5 +92,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDeltaObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RunStepDeltaObject),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RunStepDeltaObject;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDeltaObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RunStepDeltaObject?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaObjectDelta.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaObjectDelta.g.cs
index be20a599..3343f68d 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaObjectDelta.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaObjectDelta.g.cs
@@ -78,5 +78,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDeltaObjectDelta?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RunStepDeltaObjectDelta),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RunStepDeltaObjectDelta;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDeltaObjectDelta?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RunStepDeltaObjectDelta?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaObjectDeltaStepDetails.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaObjectDeltaStepDetails.g.cs
index 3de0ca21..92807f88 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaObjectDeltaStepDetails.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaObjectDeltaStepDetails.g.cs
@@ -276,5 +276,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDeltaObjectDeltaStepDetails?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RunStepDeltaObjectDeltaStepDetails),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RunStepDeltaObjectDeltaStepDetails?;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDeltaObjectDeltaStepDetails?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RunStepDeltaObjectDeltaStepDetails?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaObjectDeltaStepDetailsDiscriminator.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaObjectDeltaStepDetailsDiscriminator.g.cs
index bf5d55fb..d7daeabf 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaObjectDeltaStepDetailsDiscriminator.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaObjectDeltaStepDetailsDiscriminator.g.cs
@@ -78,5 +78,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDeltaObjectDeltaStepDetailsDiscriminator?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RunStepDeltaObjectDeltaStepDetailsDiscriminator),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RunStepDeltaObjectDeltaStepDetailsDiscriminator;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDeltaObjectDeltaStepDetailsDiscriminator?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RunStepDeltaObjectDeltaStepDetailsDiscriminator?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaStepDetailsMessageCreationObject.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaStepDetailsMessageCreationObject.g.cs
index dbf81de4..95786343 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaStepDetailsMessageCreationObject.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaStepDetailsMessageCreationObject.g.cs
@@ -84,5 +84,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDeltaStepDetailsMessageCreationObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RunStepDeltaStepDetailsMessageCreationObject),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RunStepDeltaStepDetailsMessageCreationObject;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDeltaStepDetailsMessageCreationObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RunStepDeltaStepDetailsMessageCreationObject?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaStepDetailsMessageCreationObjectMessageCreation.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaStepDetailsMessageCreationObjectMessageCreation.g.cs
index bd037dfd..faa5cff8 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaStepDetailsMessageCreationObjectMessageCreation.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaStepDetailsMessageCreationObjectMessageCreation.g.cs
@@ -77,5 +77,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDeltaStepDetailsMessageCreationObjectMessageCreation?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RunStepDeltaStepDetailsMessageCreationObjectMessageCreation),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RunStepDeltaStepDetailsMessageCreationObjectMessageCreation;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDeltaStepDetailsMessageCreationObjectMessageCreation?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RunStepDeltaStepDetailsMessageCreationObjectMessageCreation?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaStepDetailsToolCallsCodeObject.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaStepDetailsToolCallsCodeObject.g.cs
index 53c9426e..fefe85d8 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaStepDetailsToolCallsCodeObject.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaStepDetailsToolCallsCodeObject.g.cs
@@ -97,5 +97,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDeltaStepDetailsToolCallsCodeObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RunStepDeltaStepDetailsToolCallsCodeObject),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RunStepDeltaStepDetailsToolCallsCodeObject;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDeltaStepDetailsToolCallsCodeObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RunStepDeltaStepDetailsToolCallsCodeObject?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaStepDetailsToolCallsCodeObjectCodeInterpreter.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaStepDetailsToolCallsCodeObjectCodeInterpreter.g.cs
index bd3086a9..4ebd3d90 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaStepDetailsToolCallsCodeObjectCodeInterpreter.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaStepDetailsToolCallsCodeObjectCodeInterpreter.g.cs
@@ -83,5 +83,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDeltaStepDetailsToolCallsCodeObjectCodeInterpreter?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RunStepDeltaStepDetailsToolCallsCodeObjectCodeInterpreter),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RunStepDeltaStepDetailsToolCallsCodeObjectCodeInterpreter;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDeltaStepDetailsToolCallsCodeObjectCodeInterpreter?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RunStepDeltaStepDetailsToolCallsCodeObjectCodeInterpreter?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaStepDetailsToolCallsCodeObjectCodeInterpreterOutput.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaStepDetailsToolCallsCodeObjectCodeInterpreterOutput.g.cs
index 9404e9de..e5b2808a 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaStepDetailsToolCallsCodeObjectCodeInterpreterOutput.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaStepDetailsToolCallsCodeObjectCodeInterpreterOutput.g.cs
@@ -276,5 +276,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDeltaStepDetailsToolCallsCodeObjectCodeInterpreterOutput?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RunStepDeltaStepDetailsToolCallsCodeObjectCodeInterpreterOutput),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RunStepDeltaStepDetailsToolCallsCodeObjectCodeInterpreterOutput?;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDeltaStepDetailsToolCallsCodeObjectCodeInterpreterOutput?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RunStepDeltaStepDetailsToolCallsCodeObjectCodeInterpreterOutput?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaStepDetailsToolCallsCodeObjectCodeInterpreterOutputDiscriminator.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaStepDetailsToolCallsCodeObjectCodeInterpreterOutputDiscriminator.g.cs
index c12b76f8..2ccf9203 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaStepDetailsToolCallsCodeObjectCodeInterpreterOutputDiscriminator.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaStepDetailsToolCallsCodeObjectCodeInterpreterOutputDiscriminator.g.cs
@@ -78,5 +78,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDeltaStepDetailsToolCallsCodeObjectCodeInterpreterOutputDiscriminator?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RunStepDeltaStepDetailsToolCallsCodeObjectCodeInterpreterOutputDiscriminator),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RunStepDeltaStepDetailsToolCallsCodeObjectCodeInterpreterOutputDiscriminator;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDeltaStepDetailsToolCallsCodeObjectCodeInterpreterOutputDiscriminator?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RunStepDeltaStepDetailsToolCallsCodeObjectCodeInterpreterOutputDiscriminator?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaStepDetailsToolCallsCodeOutputImageObject.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaStepDetailsToolCallsCodeOutputImageObject.g.cs
index 094ac20f..fb8d0b68 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaStepDetailsToolCallsCodeOutputImageObject.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaStepDetailsToolCallsCodeOutputImageObject.g.cs
@@ -91,5 +91,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDeltaStepDetailsToolCallsCodeOutputImageObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RunStepDeltaStepDetailsToolCallsCodeOutputImageObject),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RunStepDeltaStepDetailsToolCallsCodeOutputImageObject;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDeltaStepDetailsToolCallsCodeOutputImageObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RunStepDeltaStepDetailsToolCallsCodeOutputImageObject?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaStepDetailsToolCallsCodeOutputImageObjectImage.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaStepDetailsToolCallsCodeOutputImageObjectImage.g.cs
index 928cbc4b..85f343e9 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaStepDetailsToolCallsCodeOutputImageObjectImage.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaStepDetailsToolCallsCodeOutputImageObjectImage.g.cs
@@ -77,5 +77,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDeltaStepDetailsToolCallsCodeOutputImageObjectImage?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RunStepDeltaStepDetailsToolCallsCodeOutputImageObjectImage),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RunStepDeltaStepDetailsToolCallsCodeOutputImageObjectImage;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDeltaStepDetailsToolCallsCodeOutputImageObjectImage?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RunStepDeltaStepDetailsToolCallsCodeOutputImageObjectImage?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaStepDetailsToolCallsCodeOutputLogsObject.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaStepDetailsToolCallsCodeOutputLogsObject.g.cs
index dfee12d1..198d2b97 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaStepDetailsToolCallsCodeOutputLogsObject.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaStepDetailsToolCallsCodeOutputLogsObject.g.cs
@@ -91,5 +91,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDeltaStepDetailsToolCallsCodeOutputLogsObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RunStepDeltaStepDetailsToolCallsCodeOutputLogsObject),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RunStepDeltaStepDetailsToolCallsCodeOutputLogsObject;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDeltaStepDetailsToolCallsCodeOutputLogsObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RunStepDeltaStepDetailsToolCallsCodeOutputLogsObject?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaStepDetailsToolCallsFileSearchObject.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaStepDetailsToolCallsFileSearchObject.g.cs
index 5fbeefef..db8489b8 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaStepDetailsToolCallsFileSearchObject.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaStepDetailsToolCallsFileSearchObject.g.cs
@@ -98,5 +98,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDeltaStepDetailsToolCallsFileSearchObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RunStepDeltaStepDetailsToolCallsFileSearchObject),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RunStepDeltaStepDetailsToolCallsFileSearchObject;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDeltaStepDetailsToolCallsFileSearchObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RunStepDeltaStepDetailsToolCallsFileSearchObject?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaStepDetailsToolCallsFileSearchObjectFileSearch.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaStepDetailsToolCallsFileSearchObjectFileSearch.g.cs
index 3fe12d8c..6308a353 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaStepDetailsToolCallsFileSearchObjectFileSearch.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaStepDetailsToolCallsFileSearchObjectFileSearch.g.cs
@@ -72,5 +72,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDeltaStepDetailsToolCallsFileSearchObjectFileSearch?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RunStepDeltaStepDetailsToolCallsFileSearchObjectFileSearch),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RunStepDeltaStepDetailsToolCallsFileSearchObjectFileSearch;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDeltaStepDetailsToolCallsFileSearchObjectFileSearch?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RunStepDeltaStepDetailsToolCallsFileSearchObjectFileSearch?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaStepDetailsToolCallsFunctionObject.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaStepDetailsToolCallsFunctionObject.g.cs
index aa4b8254..e0d32bff 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaStepDetailsToolCallsFunctionObject.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaStepDetailsToolCallsFunctionObject.g.cs
@@ -97,5 +97,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDeltaStepDetailsToolCallsFunctionObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RunStepDeltaStepDetailsToolCallsFunctionObject),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RunStepDeltaStepDetailsToolCallsFunctionObject;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDeltaStepDetailsToolCallsFunctionObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RunStepDeltaStepDetailsToolCallsFunctionObject?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaStepDetailsToolCallsFunctionObjectFunction.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaStepDetailsToolCallsFunctionObjectFunction.g.cs
index b5133c30..17c4ded7 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaStepDetailsToolCallsFunctionObjectFunction.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaStepDetailsToolCallsFunctionObjectFunction.g.cs
@@ -89,5 +89,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDeltaStepDetailsToolCallsFunctionObjectFunction?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RunStepDeltaStepDetailsToolCallsFunctionObjectFunction),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RunStepDeltaStepDetailsToolCallsFunctionObjectFunction;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDeltaStepDetailsToolCallsFunctionObjectFunction?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RunStepDeltaStepDetailsToolCallsFunctionObjectFunction?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaStepDetailsToolCallsObject.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaStepDetailsToolCallsObject.g.cs
index 0e8eb7d9..83d3aabe 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaStepDetailsToolCallsObject.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaStepDetailsToolCallsObject.g.cs
@@ -84,5 +84,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDeltaStepDetailsToolCallsObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RunStepDeltaStepDetailsToolCallsObject),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RunStepDeltaStepDetailsToolCallsObject;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDeltaStepDetailsToolCallsObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RunStepDeltaStepDetailsToolCallsObject?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaStepDetailsToolCallsObjectToolCallDiscriminator.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaStepDetailsToolCallsObjectToolCallDiscriminator.g.cs
index a8ad3eab..dce279e7 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaStepDetailsToolCallsObjectToolCallDiscriminator.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDeltaStepDetailsToolCallsObjectToolCallDiscriminator.g.cs
@@ -78,5 +78,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDeltaStepDetailsToolCallsObjectToolCallDiscriminator?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RunStepDeltaStepDetailsToolCallsObjectToolCallDiscriminator),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RunStepDeltaStepDetailsToolCallsObjectToolCallDiscriminator;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDeltaStepDetailsToolCallsObjectToolCallDiscriminator?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RunStepDeltaStepDetailsToolCallsObjectToolCallDiscriminator?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsMessageCreationObject.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsMessageCreationObject.g.cs
index bba3e613..c43f69d4 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsMessageCreationObject.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsMessageCreationObject.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDetailsMessageCreationObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RunStepDetailsMessageCreationObject),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RunStepDetailsMessageCreationObject;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDetailsMessageCreationObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RunStepDetailsMessageCreationObject?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsMessageCreationObjectMessageCreation.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsMessageCreationObjectMessageCreation.g.cs
index 22fbb0ac..b3735858 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsMessageCreationObjectMessageCreation.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsMessageCreationObjectMessageCreation.g.cs
@@ -78,5 +78,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDetailsMessageCreationObjectMessageCreation?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RunStepDetailsMessageCreationObjectMessageCreation),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RunStepDetailsMessageCreationObjectMessageCreation;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDetailsMessageCreationObjectMessageCreation?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RunStepDetailsMessageCreationObjectMessageCreation?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsToolCallsCodeObject.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsToolCallsCodeObject.g.cs
index 43e2d4e2..f4620885 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsToolCallsCodeObject.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsToolCallsCodeObject.g.cs
@@ -92,5 +92,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDetailsToolCallsCodeObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RunStepDetailsToolCallsCodeObject),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RunStepDetailsToolCallsCodeObject;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDetailsToolCallsCodeObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RunStepDetailsToolCallsCodeObject?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsToolCallsCodeObjectCodeInterpreter.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsToolCallsCodeObjectCodeInterpreter.g.cs
index 97530bd3..75b4cce7 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsToolCallsCodeObjectCodeInterpreter.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsToolCallsCodeObjectCodeInterpreter.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDetailsToolCallsCodeObjectCodeInterpreter?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RunStepDetailsToolCallsCodeObjectCodeInterpreter),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RunStepDetailsToolCallsCodeObjectCodeInterpreter;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDetailsToolCallsCodeObjectCodeInterpreter?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RunStepDetailsToolCallsCodeObjectCodeInterpreter?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsToolCallsCodeObjectCodeInterpreterOutput.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsToolCallsCodeObjectCodeInterpreterOutput.g.cs
index 6771a4aa..8cd6224b 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsToolCallsCodeObjectCodeInterpreterOutput.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsToolCallsCodeObjectCodeInterpreterOutput.g.cs
@@ -276,5 +276,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDetailsToolCallsCodeObjectCodeInterpreterOutput?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RunStepDetailsToolCallsCodeObjectCodeInterpreterOutput),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RunStepDetailsToolCallsCodeObjectCodeInterpreterOutput?;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDetailsToolCallsCodeObjectCodeInterpreterOutput?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RunStepDetailsToolCallsCodeObjectCodeInterpreterOutput?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsToolCallsCodeObjectCodeInterpreterOutputDiscriminator.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsToolCallsCodeObjectCodeInterpreterOutputDiscriminator.g.cs
index b66d512c..761c89c2 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsToolCallsCodeObjectCodeInterpreterOutputDiscriminator.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsToolCallsCodeObjectCodeInterpreterOutputDiscriminator.g.cs
@@ -78,5 +78,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDetailsToolCallsCodeObjectCodeInterpreterOutputDiscriminator?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RunStepDetailsToolCallsCodeObjectCodeInterpreterOutputDiscriminator),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RunStepDetailsToolCallsCodeObjectCodeInterpreterOutputDiscriminator;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDetailsToolCallsCodeObjectCodeInterpreterOutputDiscriminator?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RunStepDetailsToolCallsCodeObjectCodeInterpreterOutputDiscriminator?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsToolCallsCodeOutputImageObject.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsToolCallsCodeOutputImageObject.g.cs
index dd7d3fdc..808f2834 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsToolCallsCodeOutputImageObject.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsToolCallsCodeOutputImageObject.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDetailsToolCallsCodeOutputImageObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RunStepDetailsToolCallsCodeOutputImageObject),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RunStepDetailsToolCallsCodeOutputImageObject;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDetailsToolCallsCodeOutputImageObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RunStepDetailsToolCallsCodeOutputImageObject?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsToolCallsCodeOutputImageObjectImage.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsToolCallsCodeOutputImageObjectImage.g.cs
index d707d18d..fb5c9899 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsToolCallsCodeOutputImageObjectImage.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsToolCallsCodeOutputImageObjectImage.g.cs
@@ -78,5 +78,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDetailsToolCallsCodeOutputImageObjectImage?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RunStepDetailsToolCallsCodeOutputImageObjectImage),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RunStepDetailsToolCallsCodeOutputImageObjectImage;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDetailsToolCallsCodeOutputImageObjectImage?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RunStepDetailsToolCallsCodeOutputImageObjectImage?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsToolCallsCodeOutputLogsObject.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsToolCallsCodeOutputLogsObject.g.cs
index aa9e1734..0d694353 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsToolCallsCodeOutputLogsObject.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsToolCallsCodeOutputLogsObject.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDetailsToolCallsCodeOutputLogsObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RunStepDetailsToolCallsCodeOutputLogsObject),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RunStepDetailsToolCallsCodeOutputLogsObject;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDetailsToolCallsCodeOutputLogsObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RunStepDetailsToolCallsCodeOutputLogsObject?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsToolCallsFileSearchObject.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsToolCallsFileSearchObject.g.cs
index f6409e39..053bd71c 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsToolCallsFileSearchObject.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsToolCallsFileSearchObject.g.cs
@@ -92,5 +92,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDetailsToolCallsFileSearchObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RunStepDetailsToolCallsFileSearchObject),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RunStepDetailsToolCallsFileSearchObject;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDetailsToolCallsFileSearchObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RunStepDetailsToolCallsFileSearchObject?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsToolCallsFileSearchObjectFileSearch.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsToolCallsFileSearchObjectFileSearch.g.cs
index f2c69d52..feabd53e 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsToolCallsFileSearchObjectFileSearch.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsToolCallsFileSearchObjectFileSearch.g.cs
@@ -83,5 +83,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDetailsToolCallsFileSearchObjectFileSearch?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RunStepDetailsToolCallsFileSearchObjectFileSearch),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RunStepDetailsToolCallsFileSearchObjectFileSearch;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDetailsToolCallsFileSearchObjectFileSearch?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RunStepDetailsToolCallsFileSearchObjectFileSearch?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsToolCallsFileSearchRankingOptionsObject.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsToolCallsFileSearchRankingOptionsObject.g.cs
index 941e3a7e..6074f2e1 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsToolCallsFileSearchRankingOptionsObject.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsToolCallsFileSearchRankingOptionsObject.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDetailsToolCallsFileSearchRankingOptionsObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RunStepDetailsToolCallsFileSearchRankingOptionsObject),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RunStepDetailsToolCallsFileSearchRankingOptionsObject;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDetailsToolCallsFileSearchRankingOptionsObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RunStepDetailsToolCallsFileSearchRankingOptionsObject?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsToolCallsFileSearchResultObject.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsToolCallsFileSearchResultObject.g.cs
index 538a8aa4..dc9eec58 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsToolCallsFileSearchResultObject.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsToolCallsFileSearchResultObject.g.cs
@@ -98,5 +98,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDetailsToolCallsFileSearchResultObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RunStepDetailsToolCallsFileSearchResultObject),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RunStepDetailsToolCallsFileSearchResultObject;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDetailsToolCallsFileSearchResultObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RunStepDetailsToolCallsFileSearchResultObject?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsToolCallsFileSearchResultObjectContentItem.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsToolCallsFileSearchResultObjectContentItem.g.cs
index e3e1276f..8bcec5f4 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsToolCallsFileSearchResultObjectContentItem.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsToolCallsFileSearchResultObjectContentItem.g.cs
@@ -84,5 +84,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDetailsToolCallsFileSearchResultObjectContentItem?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RunStepDetailsToolCallsFileSearchResultObjectContentItem),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RunStepDetailsToolCallsFileSearchResultObjectContentItem;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDetailsToolCallsFileSearchResultObjectContentItem?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RunStepDetailsToolCallsFileSearchResultObjectContentItem?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsToolCallsFunctionObject.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsToolCallsFunctionObject.g.cs
index 5a02f923..1cd9bef8 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsToolCallsFunctionObject.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsToolCallsFunctionObject.g.cs
@@ -92,5 +92,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDetailsToolCallsFunctionObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RunStepDetailsToolCallsFunctionObject),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RunStepDetailsToolCallsFunctionObject;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDetailsToolCallsFunctionObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RunStepDetailsToolCallsFunctionObject?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsToolCallsFunctionObjectFunction.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsToolCallsFunctionObjectFunction.g.cs
index 3dbe2e12..f3a3b89c 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsToolCallsFunctionObjectFunction.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsToolCallsFunctionObjectFunction.g.cs
@@ -92,5 +92,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDetailsToolCallsFunctionObjectFunction?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RunStepDetailsToolCallsFunctionObjectFunction),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RunStepDetailsToolCallsFunctionObjectFunction;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDetailsToolCallsFunctionObjectFunction?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RunStepDetailsToolCallsFunctionObjectFunction?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsToolCallsObject.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsToolCallsObject.g.cs
index 5925410f..ad32e970 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsToolCallsObject.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsToolCallsObject.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDetailsToolCallsObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RunStepDetailsToolCallsObject),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RunStepDetailsToolCallsObject;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDetailsToolCallsObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RunStepDetailsToolCallsObject?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsToolCallsObjectToolCallDiscriminator.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsToolCallsObjectToolCallDiscriminator.g.cs
index 72d25fd4..3d5cfbd4 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsToolCallsObjectToolCallDiscriminator.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepDetailsToolCallsObjectToolCallDiscriminator.g.cs
@@ -78,5 +78,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDetailsToolCallsObjectToolCallDiscriminator?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RunStepDetailsToolCallsObjectToolCallDiscriminator),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RunStepDetailsToolCallsObjectToolCallDiscriminator;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepDetailsToolCallsObjectToolCallDiscriminator?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RunStepDetailsToolCallsObjectToolCallDiscriminator?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepObject.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepObject.g.cs
index f4b2f7f8..e9cc0743 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepObject.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepObject.g.cs
@@ -189,5 +189,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RunStepObject),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RunStepObject;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RunStepObject?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepObjectLastError.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepObjectLastError.g.cs
index 1d552194..bfd96173 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepObjectLastError.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepObjectLastError.g.cs
@@ -86,5 +86,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepObjectLastError?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RunStepObjectLastError),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RunStepObjectLastError;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepObjectLastError?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RunStepObjectLastError?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepObjectMetadata.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepObjectMetadata.g.cs
index 30c689bd..6ff6d0ac 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepObjectMetadata.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepObjectMetadata.g.cs
@@ -72,5 +72,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepObjectMetadata?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RunStepObjectMetadata),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RunStepObjectMetadata;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepObjectMetadata?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RunStepObjectMetadata?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepObjectStepDetails.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepObjectStepDetails.g.cs
index 7c3ce300..388cf256 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepObjectStepDetails.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepObjectStepDetails.g.cs
@@ -276,5 +276,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepObjectStepDetails?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RunStepObjectStepDetails),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RunStepObjectStepDetails?;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepObjectStepDetails?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RunStepObjectStepDetails?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepObjectStepDetailsDiscriminator.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepObjectStepDetailsDiscriminator.g.cs
index 6042664c..b3b358f7 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RunStepObjectStepDetailsDiscriminator.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RunStepObjectStepDetailsDiscriminator.g.cs
@@ -78,5 +78,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepObjectStepDetailsDiscriminator?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RunStepObjectStepDetailsDiscriminator),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RunStepObjectStepDetailsDiscriminator;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RunStepObjectStepDetailsDiscriminator?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RunStepObjectStepDetailsDiscriminator?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RunToolCallObject.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RunToolCallObject.g.cs
index ff0019ae..a8ce43fb 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RunToolCallObject.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RunToolCallObject.g.cs
@@ -92,5 +92,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RunToolCallObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RunToolCallObject),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RunToolCallObject;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RunToolCallObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RunToolCallObject?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.RunToolCallObjectFunction.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.RunToolCallObjectFunction.g.cs
index 4fdc1f9c..9ec4d1c6 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.RunToolCallObjectFunction.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.RunToolCallObjectFunction.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.RunToolCallObjectFunction?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.RunToolCallObjectFunction),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.RunToolCallObjectFunction;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.RunToolCallObjectFunction?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.RunToolCallObjectFunction?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.StaticChunkingStrategy.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.StaticChunkingStrategy.g.cs
index 49805e51..d3b82500 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.StaticChunkingStrategy.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.StaticChunkingStrategy.g.cs
@@ -86,5 +86,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.StaticChunkingStrategy?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.StaticChunkingStrategy),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.StaticChunkingStrategy;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.StaticChunkingStrategy?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.StaticChunkingStrategy?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.StaticChunkingStrategyRequestParam.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.StaticChunkingStrategyRequestParam.g.cs
index 44d6999a..a07435ab 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.StaticChunkingStrategyRequestParam.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.StaticChunkingStrategyRequestParam.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.StaticChunkingStrategyRequestParam?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.StaticChunkingStrategyRequestParam),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.StaticChunkingStrategyRequestParam;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.StaticChunkingStrategyRequestParam?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.StaticChunkingStrategyRequestParam?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.StaticChunkingStrategyResponseParam.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.StaticChunkingStrategyResponseParam.g.cs
index b7257464..e294d8c4 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.StaticChunkingStrategyResponseParam.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.StaticChunkingStrategyResponseParam.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.StaticChunkingStrategyResponseParam?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.StaticChunkingStrategyResponseParam),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.StaticChunkingStrategyResponseParam;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.StaticChunkingStrategyResponseParam?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.StaticChunkingStrategyResponseParam?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.SubmitToolOutputsRunRequest.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.SubmitToolOutputsRunRequest.g.cs
index 218a72a9..08ca20cd 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.SubmitToolOutputsRunRequest.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.SubmitToolOutputsRunRequest.g.cs
@@ -84,5 +84,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.SubmitToolOutputsRunRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.SubmitToolOutputsRunRequest),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.SubmitToolOutputsRunRequest;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.SubmitToolOutputsRunRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.SubmitToolOutputsRunRequest?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.SubmitToolOutputsRunRequestToolOutput.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.SubmitToolOutputsRunRequestToolOutput.g.cs
index 2f1d58af..80f795f1 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.SubmitToolOutputsRunRequestToolOutput.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.SubmitToolOutputsRunRequestToolOutput.g.cs
@@ -83,5 +83,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.SubmitToolOutputsRunRequestToolOutput?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.SubmitToolOutputsRunRequestToolOutput),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.SubmitToolOutputsRunRequestToolOutput;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.SubmitToolOutputsRunRequestToolOutput?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.SubmitToolOutputsRunRequestToolOutput?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ThreadObject.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ThreadObject.g.cs
index e469f73d..504475a3 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ThreadObject.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ThreadObject.g.cs
@@ -107,5 +107,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ThreadObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ThreadObject),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ThreadObject;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ThreadObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ThreadObject?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ThreadObjectMetadata.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ThreadObjectMetadata.g.cs
index 5f4a561e..73d91dbd 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ThreadObjectMetadata.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ThreadObjectMetadata.g.cs
@@ -72,5 +72,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ThreadObjectMetadata?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ThreadObjectMetadata),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ThreadObjectMetadata;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ThreadObjectMetadata?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ThreadObjectMetadata?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ThreadObjectToolResources.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ThreadObjectToolResources.g.cs
index f37c906e..f300225e 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ThreadObjectToolResources.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ThreadObjectToolResources.g.cs
@@ -83,5 +83,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ThreadObjectToolResources?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ThreadObjectToolResources),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ThreadObjectToolResources;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ThreadObjectToolResources?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ThreadObjectToolResources?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ThreadObjectToolResourcesCodeInterpreter.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ThreadObjectToolResourcesCodeInterpreter.g.cs
index ba87e1c0..96f5b5fe 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ThreadObjectToolResourcesCodeInterpreter.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ThreadObjectToolResourcesCodeInterpreter.g.cs
@@ -77,5 +77,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ThreadObjectToolResourcesCodeInterpreter?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ThreadObjectToolResourcesCodeInterpreter),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ThreadObjectToolResourcesCodeInterpreter;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ThreadObjectToolResourcesCodeInterpreter?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ThreadObjectToolResourcesCodeInterpreter?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ThreadObjectToolResourcesFileSearch.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ThreadObjectToolResourcesFileSearch.g.cs
index 8a04231f..5c14ff25 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ThreadObjectToolResourcesFileSearch.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ThreadObjectToolResourcesFileSearch.g.cs
@@ -77,5 +77,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ThreadObjectToolResourcesFileSearch?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ThreadObjectToolResourcesFileSearch),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ThreadObjectToolResourcesFileSearch;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ThreadObjectToolResourcesFileSearch?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ThreadObjectToolResourcesFileSearch?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ToolCallsItem.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ToolCallsItem.g.cs
index c8a4dad4..947674bc 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ToolCallsItem.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ToolCallsItem.g.cs
@@ -327,5 +327,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ToolCallsItem?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ToolCallsItem),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ToolCallsItem?;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ToolCallsItem?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ToolCallsItem?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ToolCallsItem2.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ToolCallsItem2.g.cs
index ede4564a..7972c4e8 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ToolCallsItem2.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ToolCallsItem2.g.cs
@@ -327,5 +327,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ToolCallsItem2?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ToolCallsItem2),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ToolCallsItem2?;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ToolCallsItem2?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ToolCallsItem2?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ToolsItem.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ToolsItem.g.cs
index aecf5c87..8e994bdb 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ToolsItem.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ToolsItem.g.cs
@@ -327,5 +327,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ToolsItem?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ToolsItem),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ToolsItem?;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ToolsItem?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ToolsItem?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ToolsItem2.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ToolsItem2.g.cs
index 29650052..2a897e87 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ToolsItem2.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ToolsItem2.g.cs
@@ -327,5 +327,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ToolsItem2?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ToolsItem2),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ToolsItem2?;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ToolsItem2?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ToolsItem2?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ToolsItem3.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ToolsItem3.g.cs
index a32d70f6..20dcf2c7 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ToolsItem3.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ToolsItem3.g.cs
@@ -276,5 +276,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ToolsItem3?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ToolsItem3),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ToolsItem3?;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ToolsItem3?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ToolsItem3?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ToolsItem4.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ToolsItem4.g.cs
index 6d802e2b..be8d8f6c 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ToolsItem4.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ToolsItem4.g.cs
@@ -327,5 +327,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ToolsItem4?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ToolsItem4),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ToolsItem4?;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ToolsItem4?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ToolsItem4?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ToolsItem5.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ToolsItem5.g.cs
index 1387efe4..9c556cbb 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ToolsItem5.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ToolsItem5.g.cs
@@ -327,5 +327,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ToolsItem5?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ToolsItem5),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ToolsItem5?;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ToolsItem5?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ToolsItem5?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ToolsItem6.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ToolsItem6.g.cs
index 1c58bf07..683dac9a 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ToolsItem6.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ToolsItem6.g.cs
@@ -276,5 +276,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ToolsItem6?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ToolsItem6),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ToolsItem6?;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ToolsItem6?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ToolsItem6?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ToolsItem7.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ToolsItem7.g.cs
index 91f63eea..22aa0849 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ToolsItem7.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ToolsItem7.g.cs
@@ -327,5 +327,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ToolsItem7?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ToolsItem7),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ToolsItem7?;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ToolsItem7?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ToolsItem7?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.ToolsItem8.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.ToolsItem8.g.cs
index 2d617ae0..c201057d 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.ToolsItem8.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.ToolsItem8.g.cs
@@ -327,5 +327,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.ToolsItem8?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.ToolsItem8),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.ToolsItem8?;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.ToolsItem8?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.ToolsItem8?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.TranscriptionSegment.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.TranscriptionSegment.g.cs
index d8b33b2c..d2a52137 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.TranscriptionSegment.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.TranscriptionSegment.g.cs
@@ -141,5 +141,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.TranscriptionSegment?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.TranscriptionSegment),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.TranscriptionSegment;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.TranscriptionSegment?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.TranscriptionSegment?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.TranscriptionWord.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.TranscriptionWord.g.cs
index 4cd61e10..bbb86f1e 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.TranscriptionWord.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.TranscriptionWord.g.cs
@@ -92,5 +92,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.TranscriptionWord?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.TranscriptionWord),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.TranscriptionWord;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.TranscriptionWord?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.TranscriptionWord?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.TruncationObject.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.TruncationObject.g.cs
index e9a0d367..06aa69d2 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.TruncationObject.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.TruncationObject.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.TruncationObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.TruncationObject),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.TruncationObject;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.TruncationObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.TruncationObject?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.UpdateVectorStoreRequest.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.UpdateVectorStoreRequest.g.cs
index 8a18dc59..33a862db 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.UpdateVectorStoreRequest.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.UpdateVectorStoreRequest.g.cs
@@ -89,5 +89,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.UpdateVectorStoreRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.UpdateVectorStoreRequest),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.UpdateVectorStoreRequest;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.UpdateVectorStoreRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.UpdateVectorStoreRequest?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.UpdateVectorStoreRequestMetadata.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.UpdateVectorStoreRequestMetadata.g.cs
index 71ce97f3..3ef3fd6f 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.UpdateVectorStoreRequestMetadata.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.UpdateVectorStoreRequestMetadata.g.cs
@@ -72,5 +72,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.UpdateVectorStoreRequestMetadata?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.UpdateVectorStoreRequestMetadata),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.UpdateVectorStoreRequestMetadata;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.UpdateVectorStoreRequestMetadata?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.UpdateVectorStoreRequestMetadata?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.Upload.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.Upload.g.cs
index 2be831b5..63ae1bc8 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.Upload.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.Upload.g.cs
@@ -136,5 +136,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.Upload?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.Upload),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.Upload;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.Upload?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.Upload?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.UploadPart.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.UploadPart.g.cs
index 68dc26f7..2096a406 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.UploadPart.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.UploadPart.g.cs
@@ -100,5 +100,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.UploadPart?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.UploadPart),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.UploadPart;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.UploadPart?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.UploadPart?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.User.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.User.g.cs
index 56312c5e..1866e196 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.User.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.User.g.cs
@@ -115,5 +115,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.User?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.User),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.User;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.User?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.User?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.UserDeleteResponse.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.UserDeleteResponse.g.cs
index b92c1bc3..3ebdeff8 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.UserDeleteResponse.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.UserDeleteResponse.g.cs
@@ -92,5 +92,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.UserDeleteResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.UserDeleteResponse),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.UserDeleteResponse;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.UserDeleteResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.UserDeleteResponse?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.UserListResponse.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.UserListResponse.g.cs
index d736555c..8f5df91f 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.UserListResponse.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.UserListResponse.g.cs
@@ -106,5 +106,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.UserListResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.UserListResponse),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.UserListResponse;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.UserListResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.UserListResponse?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.UserRoleUpdateRequest.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.UserRoleUpdateRequest.g.cs
index a7394c74..c2fe7a84 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.UserRoleUpdateRequest.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.UserRoleUpdateRequest.g.cs
@@ -79,5 +79,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.UserRoleUpdateRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.UserRoleUpdateRequest),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.UserRoleUpdateRequest;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.UserRoleUpdateRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.UserRoleUpdateRequest?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.VectorStoreExpirationAfter.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.VectorStoreExpirationAfter.g.cs
index 9d94f01e..baaa80a9 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.VectorStoreExpirationAfter.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.VectorStoreExpirationAfter.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.VectorStoreExpirationAfter?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.VectorStoreExpirationAfter),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.VectorStoreExpirationAfter;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.VectorStoreExpirationAfter?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.VectorStoreExpirationAfter?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.VectorStoreFileBatchObject.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.VectorStoreFileBatchObject.g.cs
index ba7e3913..944abe71 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.VectorStoreFileBatchObject.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.VectorStoreFileBatchObject.g.cs
@@ -115,5 +115,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.VectorStoreFileBatchObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.VectorStoreFileBatchObject),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.VectorStoreFileBatchObject;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.VectorStoreFileBatchObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.VectorStoreFileBatchObject?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.VectorStoreFileBatchObjectFileCounts.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.VectorStoreFileBatchObjectFileCounts.g.cs
index afd0f5b9..2b7fa6c3 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.VectorStoreFileBatchObjectFileCounts.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.VectorStoreFileBatchObjectFileCounts.g.cs
@@ -106,5 +106,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.VectorStoreFileBatchObjectFileCounts?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.VectorStoreFileBatchObjectFileCounts),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.VectorStoreFileBatchObjectFileCounts;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.VectorStoreFileBatchObjectFileCounts?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.VectorStoreFileBatchObjectFileCounts?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.VectorStoreFileObject.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.VectorStoreFileObject.g.cs
index 0f465586..e4ebf19b 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.VectorStoreFileObject.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.VectorStoreFileObject.g.cs
@@ -129,5 +129,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.VectorStoreFileObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.VectorStoreFileObject),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.VectorStoreFileObject;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.VectorStoreFileObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.VectorStoreFileObject?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.VectorStoreFileObjectChunkingStrategy.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.VectorStoreFileObjectChunkingStrategy.g.cs
index 9b0270e4..fc2d5e8f 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.VectorStoreFileObjectChunkingStrategy.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.VectorStoreFileObjectChunkingStrategy.g.cs
@@ -276,5 +276,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.VectorStoreFileObjectChunkingStrategy?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.VectorStoreFileObjectChunkingStrategy),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.VectorStoreFileObjectChunkingStrategy?;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.VectorStoreFileObjectChunkingStrategy?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.VectorStoreFileObjectChunkingStrategy?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.VectorStoreFileObjectChunkingStrategyDiscriminator.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.VectorStoreFileObjectChunkingStrategyDiscriminator.g.cs
index a2e0caa4..357de256 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.VectorStoreFileObjectChunkingStrategyDiscriminator.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.VectorStoreFileObjectChunkingStrategyDiscriminator.g.cs
@@ -78,5 +78,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.VectorStoreFileObjectChunkingStrategyDiscriminator?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.VectorStoreFileObjectChunkingStrategyDiscriminator),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.VectorStoreFileObjectChunkingStrategyDiscriminator;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.VectorStoreFileObjectChunkingStrategyDiscriminator?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.VectorStoreFileObjectChunkingStrategyDiscriminator?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.VectorStoreFileObjectLastError.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.VectorStoreFileObjectLastError.g.cs
index c2750a1f..31a29ced 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.VectorStoreFileObjectLastError.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.VectorStoreFileObjectLastError.g.cs
@@ -86,5 +86,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.VectorStoreFileObjectLastError?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.VectorStoreFileObjectLastError),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.VectorStoreFileObjectLastError;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.VectorStoreFileObjectLastError?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.VectorStoreFileObjectLastError?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.VectorStoreObject.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.VectorStoreObject.g.cs
index 9940da16..a075ec7f 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.VectorStoreObject.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.VectorStoreObject.g.cs
@@ -150,5 +150,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.VectorStoreObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.VectorStoreObject),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.VectorStoreObject;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.VectorStoreObject?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.VectorStoreObject?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.VectorStoreObjectFileCounts.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.VectorStoreObjectFileCounts.g.cs
index 16d503a7..87ac8680 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.VectorStoreObjectFileCounts.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.VectorStoreObjectFileCounts.g.cs
@@ -106,5 +106,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.VectorStoreObjectFileCounts?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.VectorStoreObjectFileCounts),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.VectorStoreObjectFileCounts;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.VectorStoreObjectFileCounts?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.VectorStoreObjectFileCounts?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/OpenAI/Generated/OpenAI.Models.VectorStoreObjectMetadata.g.cs b/src/libs/OpenAI/Generated/OpenAI.Models.VectorStoreObjectMetadata.g.cs
index 9941e8d8..f2d89215 100644
--- a/src/libs/OpenAI/Generated/OpenAI.Models.VectorStoreObjectMetadata.g.cs
+++ b/src/libs/OpenAI/Generated/OpenAI.Models.VectorStoreObjectMetadata.g.cs
@@ -72,5 +72,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::OpenAI.VectorStoreObjectMetadata?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::OpenAI.VectorStoreObjectMetadata),
+                jsonSerializerContext).ConfigureAwait(false)) as global::OpenAI.VectorStoreObjectMetadata;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#if NET8_0_OR_GREATER
+        [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
+        [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")]
+#endif
+        public static global::System.Threading.Tasks.ValueTask<global::OpenAI.VectorStoreObjectMetadata?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::OpenAI.VectorStoreObjectMetadata?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file