fix: auto-detect MIME type for file uploads (fixes image upload error)

- Add MimeTypes helper mapping 18 extensions to Content-Type
- UploadFileDataAsync/ResumableAsync now use detected MIME from fileName
- Fixes 'Error reading file from request in direct mode' on iu.oneme.ru CDN
- Document format restrictions: HTML/unsupported extensions return 'File extension is forbidden'
- Add unit tests for MIME detection (image, unknown, null)
- Bump version 0.6.2-alpha -> 0.6.3-alpha
- Update CHANGELOG

Author: CrazyAngelm

CHANGELOG.md

@@ -6,6 +6,20 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
+## [0.6.3-alpha] - 2026-06-08
+
+### Fixed
+
+- **Image/Video/Audio upload MIME type**: `UploadFileDataAsync` and `UploadFileResumableAsync` no longer hardcode `Content-Type: application/octet-stream`. The MIME type is now auto-detected from the file name extension (e.g. `image/jpeg` for `.jpg`) and falls back to `application/octet-stream` for unknown extensions. This fixes the `"Error reading file from request in direct mode"` error that occurred when uploading images to the `iu.oneme.ru` CDN, which requires a correct MIME type for validation.
+
+### Added
+
+- **MIME type helper**: `Max.Bot.Networking.MimeTypes` maps 18 common file extensions to `Content-Type` values for images, video, and audio.
+
+### Changed
+
+- **Format restrictions documented**: `IFilesApi.UploadFileAsync` XML docs now note that unsupported extensions (e.g. `.html`) return `"File extension is forbidden"` from the Max API, and list supported formats per upload type.
+
 
 ## [0.6.2-alpha] - 2026-05-14
 

src/Max.Bot/Api/FilesApi.cs

@@ -51,7 +51,7 @@ HttpContent CreateContent()
         {
             var content = new MultipartFormDataContent();
             var streamContent = new StreamContent(new NonDisposingStreamWrapper(fileStream));
-            streamContent.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream");
+            streamContent.Headers.ContentType = new MediaTypeHeaderValue(MimeTypes.FromFileName(fileName) ?? "application/octet-stream");
             content.Add(streamContent, "data", fileName ?? "file");
             return content;
         }
@@ -86,7 +86,7 @@ public async Task<FileUploadResult> UploadFileResumableAsync(string uploadUrl, S
             HttpContent CreateChunkContent()
             {
                 var content = new ByteArrayContent(chunkData);
-                content.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream");
+                content.Headers.ContentType = new MediaTypeHeaderValue(MimeTypes.FromFileName(fileName) ?? "application/octet-stream");
                 // Always send Content-Range. If length unknown, use '*'
                 content.Headers.ContentRange = fileLength > 0
                     ? new ContentRangeHeaderValue(currentOffset, currentOffset + currentBytesRead - 1, fileLength)

src/Max.Bot/Api/IFilesApi.cs

@@ -14,6 +14,15 @@ public interface IFilesApi
     /// <summary>
     /// Uploads a file and returns an upload URL and optional token.
     /// </summary>
+    /// <remarks>
+    /// <para>Max API restricts supported formats:</para>
+    /// <list type="bullet">
+    /// <item><description>For <c>type=file</c>, unsupported extensions (e.g. <c>.html</c>) return 'File extension is forbidden'.</description></item>
+    /// <item><description>For <c>type=image</c>, supported formats: JPG, JPEG, PNG, GIF, TIFF, BMP, HEIC.</description></item>
+    /// <item><description>For <c>type=video</c>, supported formats: MP4, MOV, MKV, WEBM.</description></item>
+    /// <item><description>For <c>type=audio</c>, supported formats: MP3, WAV, M4A and others.</description></item>
+    /// </list>
+    /// </remarks>
     /// <param name="uploadType">The type of file to upload.</param>
     /// <param name="cancellationToken">A cancellation token to cancel the operation.</param>
     /// <returns>A task that represents the asynchronous operation. The task result contains the upload response with URL and optional token.</returns>
@@ -27,8 +36,8 @@ public interface IFilesApi
     /// </summary>
     /// <param name="uploadUrl">The upload URL obtained from UploadFileAsync.</param>
     /// <param name="fileStream">The stream containing the file data to upload.</param>
-    /// <param name="fileName">The name of the file. Optional.</param>
     /// <param name="cancellationToken">A cancellation token to cancel the operation.</param>
+    /// <param name="fileName">The name of the file. Used to determine the MIME type. If the extension is unknown, falls back to "application/octet-stream". Optional.</param>
     /// <returns>A task that represents the asynchronous operation. The task result contains the upload result with a token.</returns>
     /// <exception cref="ArgumentException">Thrown when uploadUrl is null or empty, or fileStream is not readable.</exception>
     /// <exception cref="ArgumentNullException">Thrown when fileStream is null.</exception>
@@ -51,4 +60,3 @@ public interface IFilesApi
     /// <exception cref="Max.Bot.Exceptions.MaxNetworkException">Thrown when a network error occurs.</exception>
     Task<FileUploadResult> UploadFileResumableAsync(string uploadUrl, Stream fileStream, long chunkSize = 1024 * 1024, string? fileName = null, CancellationToken cancellationToken = default);
 }
-

src/Max.Bot/Max.Bot.csproj

@@ -5,7 +5,7 @@
     <Nullable>enable</Nullable>
 
     <PackageId>MaxMessenger.Bot</PackageId>
-    <Version>0.6.2-alpha</Version>
+    <Version>0.6.3-alpha</Version>
     <Authors>MaxBotNet Contributors</Authors>
     <Description>C# library for Max Messenger Bot API (.NET 10, .NET 9, .NET 8)</Description>
     <PackageLicenseExpression>Apache-2.0</PackageLicenseExpression>

src/Max.Bot/Networking/MimeTypes.cs

@@ -0,0 +1,41 @@
+using System.Collections.Generic;
+
+namespace Max.Bot.Networking;
+
+/// <summary>
+/// Maps file extensions to MIME types for upload Content-Type detection.
+/// </summary>
+internal static class MimeTypes
+{
+    private static readonly Dictionary<string, string> Map = new(StringComparer.OrdinalIgnoreCase)
+    {
+        { ".jpg",  "image/jpeg" },
+        { ".jpeg", "image/jpeg" },
+        { ".png",  "image/png" },
+        { ".gif",  "image/gif" },
+        { ".webp", "image/webp" },
+        { ".bmp",  "image/bmp" },
+        { ".tiff", "image/tiff" },
+        { ".tif",  "image/tiff" },
+        { ".heic", "image/heic" },
+        { ".mp4",       "video/mp4" },
+        { ".mov",       "video/quicktime" },
+        { ".mkv",       "video/x-matroska" },
+        { ".webm",      "video/webm" },
+        { ".mp3",  "audio/mpeg" },
+        { ".wav",  "audio/wav" },
+        { ".m4a",  "audio/mp4" },
+        { ".ogg",  "audio/ogg" },
+        { ".opus", "audio/opus" },
+    };
+
+    internal static string? FromFileName(string? fileName)
+    {
+        if (string.IsNullOrWhiteSpace(fileName))
+            return null;
+        var ext = fileName.LastIndexOf('.') is >= 0 and var idx
+            ? fileName[idx..]
+            : fileName;
+        return Map.TryGetValue(ext, out var mime) ? mime : null;
+    }
+}

tests/Max.Bot.Tests/Unit/Api/FilesApiTests.cs

@@ -255,17 +255,105 @@ await act.Should().ThrowAsync<ArgumentException>()
     public async Task UploadFileDataAsync_ShouldReturnFileUploadResult_WhenRequestSucceeds()
     {
         // Arrange
-        var responseJson = "{\"token\":\"test-token\",\"file_id\":12345}";
-        var mockResponse = new HttpResponseMessage(HttpStatusCode.OK)
-        {
-            Content = new StringContent(responseJson)
-        };
+        var uploadUrl = "https://example.com/upload";
+        var expectedToken = "test-token-upload";
+        var responseJson = JsonSerializer.Serialize(new { token = expectedToken, file_id = 12345 });
+
+        Func<HttpContent?>? capturedFactory = null;
+        _mockHttpClient
+            .Setup(x => x.SendAsyncRaw(
+                uploadUrl,
+                It.IsAny<Func<HttpContent?>>(),
+                It.IsAny<CancellationToken>(),
+                It.IsAny<HttpMethod?>()))
+            .Callback<string, Func<HttpContent?>?, CancellationToken, HttpMethod?>((_, factory, _, _) =>
+            {
+                capturedFactory = factory;
+            })
+            .ReturnsAsync(responseJson);
+
+        var filesApi = new FilesApi(_mockHttpClient.Object, _options);
+        using var stream = new MemoryStream([1, 2, 3]);
+
+        // Act
+        var result = await filesApi.UploadFileDataAsync(uploadUrl, stream, "photo.jpg");
+
+        // Assert
+        result.Should().NotBeNull();
+        result.Token.Should().Be(expectedToken);
 
-        // We need to use a real HttpClient or mock the SendAsync
-        // Since FilesApi creates its own HttpClient, we might need to adjust it for testing
-        // or rely on the IMaxHttpClient if it was used.
-        // Wait, FilesApi.cs: _httpClient = new HttpClient { ... };
-        // This makes it hard to test without reflection or a wrapper.
+        capturedFactory.Should().NotBeNull();
+        var content = capturedFactory!();
+        content.Should().NotBeNull();
+        var body = await content!.ReadAsStringAsync();
+        body.Should().Contain("Content-Type: image/jpeg");
     }
-}
 
+    [Fact]
+    public async Task UploadFileDataAsync_ShouldUseOctetStream_WhenExtensionUnknown()
+    {
+        // Arrange
+        var uploadUrl = "https://example.com/upload";
+        var responseJson = JsonSerializer.Serialize(new { token = "test-token" });
+
+        Func<HttpContent?>? capturedFactory = null;
+        _mockHttpClient
+            .Setup(x => x.SendAsyncRaw(
+                uploadUrl,
+                It.IsAny<Func<HttpContent?>>(),
+                It.IsAny<CancellationToken>(),
+                It.IsAny<HttpMethod?>()))
+            .Callback<string, Func<HttpContent?>?, CancellationToken, HttpMethod?>((_, factory, _, _) =>
+            {
+                capturedFactory = factory;
+            })
+            .ReturnsAsync(responseJson);
+
+        var filesApi = new FilesApi(_mockHttpClient.Object, _options);
+        using var stream = new MemoryStream([1, 2, 3]);
+
+        // Act
+        await filesApi.UploadFileDataAsync(uploadUrl, stream, "data.bin");
+
+        // Assert
+        capturedFactory.Should().NotBeNull();
+        var content = capturedFactory!();
+        content.Should().NotBeNull();
+        var body = await content!.ReadAsStringAsync();
+        body.Should().Contain("Content-Type: application/octet-stream");
+    }
+
+    [Fact]
+    public async Task UploadFileDataAsync_ShouldUseOctetStream_WhenFileNameNull()
+    {
+        // Arrange
+        var uploadUrl = "https://example.com/upload";
+        var responseJson = JsonSerializer.Serialize(new { token = "test-token" });
+
+        Func<HttpContent?>? capturedFactory = null;
+        _mockHttpClient
+            .Setup(x => x.SendAsyncRaw(
+                uploadUrl,
+                It.IsAny<Func<HttpContent?>>(),
+                It.IsAny<CancellationToken>(),
+                It.IsAny<HttpMethod?>()))
+            .Callback<string, Func<HttpContent?>?, CancellationToken, HttpMethod?>((_, factory, _, _) =>
+            {
+                capturedFactory = factory;
+            })
+            .ReturnsAsync(responseJson);
+
+        var filesApi = new FilesApi(_mockHttpClient.Object, _options);
+        using var stream = new MemoryStream([1, 2, 3]);
+
+        // Act
+        await filesApi.UploadFileDataAsync(uploadUrl, stream, null);
+
+        // Assert
+        capturedFactory.Should().NotBeNull();
+        var content = capturedFactory!();
+        content.Should().NotBeNull();
+        var body = await content!.ReadAsStringAsync();
+        body.Should().Contain("Content-Type: application/octet-stream");
+    }
+}