feat: add dedicated polling HttpClient with infinite timeout for long polling

Separate HttpClient with Timeout.InfiniteTimeSpan prevents TaskCanceledException
during long polling when server holds connection up to 90 seconds.

- Add internal IBotClientInternal interface with PollingSendRequest (explicit impl)
- Add PollingProcessApi/GetUpdatesFromPolling parallel to existing ProcessApi/GetUpdates
- Lazy-create polling HttpClient on first use
- Implement IDisposable with _ownsHttpClient tracking for safe cleanup

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: Deskri

src/Max.BotClient/Max.BotClient.ApiExtensions.cs

@@ -72,5 +72,18 @@ public static async Task ProcessApi<TParams>(
             ApiRequestBinder.Bind(createParams(), basePath, out var path, out var body);
             await botClient.SendRequest<object>(method, path, body, cancellationToken);
         }
+        
+        internal static async Task<TResult> PollingProcessApi<TParams, TDto, TResult>(
+            this IBotClientInternal botClient,
+            HttpMethod method,
+            string basePath,
+            Func<TParams> createParams,
+            CancellationToken cancellationToken = default
+        ) where TParams : class
+        {
+            ApiRequestBinder.Bind(createParams(), basePath, out var path, out var body);
+            var dto = await botClient.PollingSendRequest<TDto>(method, path, body, cancellationToken);
+            return dto.ToResult<TDto, TResult>();
+        }
     }
 }

src/Max.BotClient/Max.BotClient.ApiMethods.Subscriptions.cs

@@ -90,5 +90,25 @@ public static async Task<SubscribeResult> Unsubscribe(
 
             return (response.Updates, response.Marker);
         }
+
+        private static async Task<(Update[], long?)> GetUpdatesFromPolling(
+            this IBotClientInternal botClient,
+            int? limit = null,
+            int? timeout = null,
+            long? marker = null,
+            Types.UpdateType[]? types = null,
+            CancellationToken cancellationToken = default
+        )
+        {
+            var response = await botClient.PollingProcessApi<GetUpdatesParams, DTOs.GetUpdatesResponse, Types.GetUpdatesResponse>(
+                HttpMethod.Get,
+                "/updates",
+                () => new GetUpdatesParams
+                    { Limit = limit, Timeout = timeout, Marker = marker, UpdateTypes = types },
+                cancellationToken
+            );
+
+            return (response.Updates, response.Marker);
+        }
     }
-}
+}

src/Max.BotClient/Max.BotClient.Polling.cs

@@ -48,13 +48,13 @@ public static void StartReceiving(
             Func<IBotClient, Exception, CancellationToken, Task>? errorHandler = null,
             ReceiverOptions? options = null,
             CancellationToken cancellationToken = default
-        ) => Task.Run(() => 
+        ) => Task.Run(() =>
                 botClient.ReceiveAsync(
-                    updateHandler, 
-                    errorHandler, 
-                    options, 
+                    updateHandler,
+                    errorHandler,
+                    options,
                     cancellationToken
-                ), 
+                ),
             cancellationToken
         );
 
@@ -83,7 +83,7 @@ public static async Task ReceiveAsync(
             {
                 try
                 {
-                    var (_, newMarker) = await botClient.GetUpdates(
+                    var (_, newMarker) = await botClient.Update(
                         limit: 1,
                         timeout: 0,
                         marker: null,
@@ -109,7 +109,7 @@ public static async Task ReceiveAsync(
 
                 try
                 {
-                    var result = await botClient.GetUpdates(
+                    var result = await botClient.Update(
                         limit: options.Limit,
                         timeout: options.Timeout,
                         marker: marker,
@@ -150,5 +150,32 @@ public static async Task ReceiveAsync(
                 }
             }
         }
+
+        private static Task<(Update[], long?)> Update(
+            this IBotClient botClient,
+            int? limit = null,
+            int? timeout = null,
+            long? marker = null,
+            Types.UpdateType[]? types = null,
+            CancellationToken cancellationToken = default
+        )
+        {
+            if (botClient is IBotClientInternal internalBotClient)
+                return internalBotClient.GetUpdatesFromPolling(
+                    limit,
+                    timeout,
+                    marker,
+                    types,
+                    cancellationToken
+                );
+            
+            return botClient.GetUpdates(
+                limit,
+                timeout,
+                marker,
+                types,
+                cancellationToken
+            );
+        }
     }
-}
+}

src/Max.BotClient/Max.BotClient.cs

@@ -19,10 +19,23 @@ Task<TResponse> SendRequest<TResponse>(
         );
     }
 
-    public partial class BotClient : IBotClient
+    internal interface IBotClientInternal : IBotClient
+    {
+        Task<TResponse> PollingSendRequest<TResponse>(
+            HttpMethod method,
+            string path,
+            object? body = null,
+            CancellationToken cancellationToken = default
+        );
+    }
+
+    public partial class BotClient : IBotClientInternal, IDisposable
     {
         private readonly BotClientOptions _options;
         private readonly HttpClient _httpClient;
+        private readonly bool _ownsHttpClient;
+        private HttpClient? _pollingHttpClient;
+        private bool _disposed;
 
         public string Token => _options.Token;
         public CancellationToken GlobalCancelToken { get; }
@@ -36,6 +49,7 @@ public BotClient(
             _options = options ?? throw new ArgumentNullException(nameof(options));
             GlobalCancelToken = cancellationToken;
 
+            _ownsHttpClient = httpClient == null;
             _httpClient = httpClient ?? new HttpClient();
             _httpClient.BaseAddress = new Uri(_options.ApiUrl);
             _httpClient.DefaultRequestHeaders.TryAddWithoutValidation("Authorization", _options.Token);
@@ -54,6 +68,34 @@ public async Task<TResponse> SendRequest<TResponse>(
             string path,
             object? body = null,
             CancellationToken cancellationToken = default
+        ) => await SendRequestCore<TResponse>(_httpClient, method, path, body, cancellationToken);
+        
+        async Task<TResponse> IBotClientInternal.PollingSendRequest<TResponse>(
+            HttpMethod method,
+            string path,
+            object? body,
+            CancellationToken cancellationToken
+        )
+        {
+            if (_pollingHttpClient == null)
+            {
+                _pollingHttpClient = new HttpClient
+                {
+                    BaseAddress = new Uri(_options.ApiUrl),
+                    Timeout = Timeout.InfiniteTimeSpan
+                };
+                _pollingHttpClient.DefaultRequestHeaders.TryAddWithoutValidation("Authorization", _options.Token);
+            }
+
+            return await SendRequestCore<TResponse>(_pollingHttpClient, method, path, body, cancellationToken);
+        }
+
+        private async Task<TResponse> SendRequestCore<TResponse>(
+            HttpClient httpClient,
+            HttpMethod method,
+            string path,
+            object? body,
+            CancellationToken cancellationToken
         )
         {
             using var cts = CancellationTokenSource.CreateLinkedTokenSource(GlobalCancelToken, cancellationToken);
@@ -78,7 +120,7 @@ public async Task<TResponse> SendRequest<TResponse>(
                     request.Content = new StringContent(json, Encoding.UTF8, "application/json");
                 }
 
-                using var response = await _httpClient.SendAsync(request, token);
+                using var response = await httpClient.SendAsync(request, token);
                 var responseBody = await response.Content.ReadAsStringAsync();
 
                 if (response.IsSuccessStatusCode)
@@ -98,5 +140,14 @@ public async Task<TResponse> SendRequest<TResponse>(
 
             throw lastException!;
         }
+
+        public void Dispose()
+        {
+            if (_disposed) return;
+            _disposed = true;
+
+            _pollingHttpClient?.Dispose();
+            if (_ownsHttpClient) _httpClient.Dispose();
+        }
     }
 }