hotifx of changelog

30.0.1

CHANGELOG.md

@@ -1,5 +1,30 @@
 # TelegramBotAPI changelog
 
+## 30.0.2
+
+* `Version`:
+    * `Kotlin`: `2.2.20` -> `2.2.21`
+    * `Ktor`: `3.3.1` -> `3.3.2`
+    * `KSP`: `2.2.20-2.0.4` -> `2.3.2`
+    * `MicroUtils`: `0.26.6` -> `0.26.8`
+    * `KSLog`: `1.5.1` -> `1.5.2`
+* `Core`:
+    * Allow to use `SetWebhook` with `maxAllowedConnections` up to `100000` (fix of [#1019](https://github.com/InsanusMokrassar/ktgbotapi/issues/1019))
+* `KSP`:
+    * Fixed annotation property access for KSP2 compatibility using `withNoSuchElementWorkaround`
+    * Removed `ksp.useKSP2=false` workaround from `gradle.properties` (KSP2 is now properly supported)
+* `Utils`:
+    * Regenerated class casts extensions
+    * Allow to use custom `GetUpdates` in `longPollingFlow`
+
+## 30.0.1
+
+* `Core`:
+  * Potential fix of [#989](https://github.com/InsanusMokrassar/ktgbotapi/issues/989) by:
+    * In long polling have been added check for causing by unresolved address exception
+    * Add `TelegramBotPipelinesHandler.onRequestExceptionInLimiter` which will be triggered in ANY exception during
+    request execution
+
 ## 30.0.0
 
 **THIS UPDATE MAY CONTAINS BREAKING CHANGES**

gradle.properties

@@ -5,8 +5,5 @@ kotlin.js.generate.externals=true
 kotlin.incremental=true
 kotlin.incremental.js=true
 
-# https://github.com/google/ksp/issues/2491
-ksp.useKSP2=false
-
 library_group=dev.inmo
-library_version=30.0.0
+library_version=30.0.2

gradle/libs.versions.toml

@@ -1,6 +1,6 @@
 [versions]
 
-kotlin = "2.2.20"
+kotlin = "2.2.21"
 kotlin-serialization = "1.9.0"
 kotlin-coroutines = "1.10.2"
 
@@ -8,13 +8,13 @@ javax-activation = "1.1.1"
 
 korlibs = "5.4.0"
 uuid = "0.8.4"
-ktor = "3.3.1"
+ktor = "3.3.2"
 
-ksp = "2.2.20-2.0.4"
+ksp = "2.3.2"
 kotlin-poet = "2.2.0"
 
-microutils = "0.26.6"
-kslog = "1.5.1"
+microutils = "0.26.8"
+kslog = "1.5.2"
 
 versions = "0.53.0"
 

tgbotapi.core/api/tgbotapi.core.api

@@ -397,6 +397,7 @@ public abstract interface class dev/inmo/tgbotapi/bot/ktor/TelegramBotPipelinesH
 	public fun onBeforeCallFactoryMakeCall (Ldev/inmo/tgbotapi/requests/abstracts/Request;Ldev/inmo/tgbotapi/bot/ktor/KtorCallFactory;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;
 	public fun onBeforeSearchCallFactory (Ldev/inmo/tgbotapi/requests/abstracts/Request;Ljava/util/List;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;
 	public fun onRequestException (Ldev/inmo/tgbotapi/requests/abstracts/Request;Ljava/lang/Throwable;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;
+	public fun onRequestExceptionInLimiter (Ldev/inmo/tgbotapi/requests/abstracts/Request;Ljava/lang/Throwable;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;
 	public fun onRequestResultAbsent (Ldev/inmo/tgbotapi/requests/abstracts/Request;Ljava/util/List;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;
 	public fun onRequestResultPresented (Ljava/lang/Object;Ldev/inmo/tgbotapi/requests/abstracts/Request;Ldev/inmo/tgbotapi/bot/ktor/KtorCallFactory;Ljava/util/List;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;
 	public fun onRequestReturnResult-3t6e044 (Ljava/lang/Object;Ldev/inmo/tgbotapi/requests/abstracts/Request;Ljava/util/List;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;
@@ -407,6 +408,7 @@ public final class dev/inmo/tgbotapi/bot/ktor/TelegramBotPipelinesHandler$Compan
 	public fun onBeforeCallFactoryMakeCall (Ldev/inmo/tgbotapi/requests/abstracts/Request;Ldev/inmo/tgbotapi/bot/ktor/KtorCallFactory;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;
 	public fun onBeforeSearchCallFactory (Ldev/inmo/tgbotapi/requests/abstracts/Request;Ljava/util/List;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;
 	public fun onRequestException (Ldev/inmo/tgbotapi/requests/abstracts/Request;Ljava/lang/Throwable;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;
+	public fun onRequestExceptionInLimiter (Ldev/inmo/tgbotapi/requests/abstracts/Request;Ljava/lang/Throwable;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;
 	public fun onRequestResultAbsent (Ldev/inmo/tgbotapi/requests/abstracts/Request;Ljava/util/List;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;
 	public fun onRequestResultPresented (Ljava/lang/Object;Ldev/inmo/tgbotapi/requests/abstracts/Request;Ldev/inmo/tgbotapi/bot/ktor/KtorCallFactory;Ljava/util/List;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;
 	public fun onRequestReturnResult-3t6e044 (Ljava/lang/Object;Ldev/inmo/tgbotapi/requests/abstracts/Request;Ljava/util/List;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;
@@ -417,6 +419,7 @@ public final class dev/inmo/tgbotapi/bot/ktor/TelegramBotPipelinesHandler$Defaul
 	public static fun onBeforeCallFactoryMakeCall (Ldev/inmo/tgbotapi/bot/ktor/TelegramBotPipelinesHandler;Ldev/inmo/tgbotapi/requests/abstracts/Request;Ldev/inmo/tgbotapi/bot/ktor/KtorCallFactory;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;
 	public static fun onBeforeSearchCallFactory (Ldev/inmo/tgbotapi/bot/ktor/TelegramBotPipelinesHandler;Ldev/inmo/tgbotapi/requests/abstracts/Request;Ljava/util/List;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;
 	public static fun onRequestException (Ldev/inmo/tgbotapi/bot/ktor/TelegramBotPipelinesHandler;Ldev/inmo/tgbotapi/requests/abstracts/Request;Ljava/lang/Throwable;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;
+	public static fun onRequestExceptionInLimiter (Ldev/inmo/tgbotapi/bot/ktor/TelegramBotPipelinesHandler;Ldev/inmo/tgbotapi/requests/abstracts/Request;Ljava/lang/Throwable;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;
 	public static fun onRequestResultAbsent (Ldev/inmo/tgbotapi/bot/ktor/TelegramBotPipelinesHandler;Ldev/inmo/tgbotapi/requests/abstracts/Request;Ljava/util/List;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;
 	public static fun onRequestResultPresented (Ldev/inmo/tgbotapi/bot/ktor/TelegramBotPipelinesHandler;Ljava/lang/Object;Ldev/inmo/tgbotapi/requests/abstracts/Request;Ldev/inmo/tgbotapi/bot/ktor/KtorCallFactory;Ljava/util/List;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;
 	public static fun onRequestReturnResult-3t6e044 (Ldev/inmo/tgbotapi/bot/ktor/TelegramBotPipelinesHandler;Ljava/lang/Object;Ldev/inmo/tgbotapi/requests/abstracts/Request;Ljava/util/List;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;
@@ -475,13 +478,14 @@ public final class dev/inmo/tgbotapi/bot/ktor/base/SimpleRequestCallFactory : de
 public class dev/inmo/tgbotapi/bot/ktor/middlewares/TelegramBotMiddleware : dev/inmo/tgbotapi/bot/ktor/TelegramBotPipelinesHandler {
 	public static final field Companion Ldev/inmo/tgbotapi/bot/ktor/middlewares/TelegramBotMiddleware$Companion;
 	public fun <init> ()V
-	public fun <init> (Lkotlin/jvm/functions/Function3;Lkotlin/jvm/functions/Function3;Lkotlin/jvm/functions/Function3;Lkotlin/jvm/functions/Function4;Lkotlin/jvm/functions/Function5;Lkotlin/jvm/functions/Function3;Lkotlin/jvm/functions/Function4;Ljava/lang/String;)V
-	public synthetic fun <init> (Lkotlin/jvm/functions/Function3;Lkotlin/jvm/functions/Function3;Lkotlin/jvm/functions/Function3;Lkotlin/jvm/functions/Function4;Lkotlin/jvm/functions/Function5;Lkotlin/jvm/functions/Function3;Lkotlin/jvm/functions/Function4;Ljava/lang/String;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public fun <init> (Lkotlin/jvm/functions/Function3;Lkotlin/jvm/functions/Function3;Lkotlin/jvm/functions/Function3;Lkotlin/jvm/functions/Function4;Lkotlin/jvm/functions/Function5;Lkotlin/jvm/functions/Function3;Lkotlin/jvm/functions/Function4;Lkotlin/jvm/functions/Function3;Ljava/lang/String;)V
+	public synthetic fun <init> (Lkotlin/jvm/functions/Function3;Lkotlin/jvm/functions/Function3;Lkotlin/jvm/functions/Function3;Lkotlin/jvm/functions/Function4;Lkotlin/jvm/functions/Function5;Lkotlin/jvm/functions/Function3;Lkotlin/jvm/functions/Function4;Lkotlin/jvm/functions/Function3;Ljava/lang/String;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
 	public final fun getId ()Ljava/lang/String;
 	public fun onAfterCallFactoryMakeCall (Ljava/lang/Object;Ldev/inmo/tgbotapi/requests/abstracts/Request;Ldev/inmo/tgbotapi/bot/ktor/KtorCallFactory;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;
 	public fun onBeforeCallFactoryMakeCall (Ldev/inmo/tgbotapi/requests/abstracts/Request;Ldev/inmo/tgbotapi/bot/ktor/KtorCallFactory;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;
 	public fun onBeforeSearchCallFactory (Ldev/inmo/tgbotapi/requests/abstracts/Request;Ljava/util/List;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;
 	public fun onRequestException (Ldev/inmo/tgbotapi/requests/abstracts/Request;Ljava/lang/Throwable;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;
+	public fun onRequestExceptionInLimiter (Ldev/inmo/tgbotapi/requests/abstracts/Request;Ljava/lang/Throwable;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;
 	public fun onRequestResultAbsent (Ldev/inmo/tgbotapi/requests/abstracts/Request;Ljava/util/List;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;
 	public fun onRequestResultPresented (Ljava/lang/Object;Ldev/inmo/tgbotapi/requests/abstracts/Request;Ldev/inmo/tgbotapi/bot/ktor/KtorCallFactory;Ljava/util/List;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;
 	public fun onRequestReturnResult-3t6e044 (Ljava/lang/Object;Ldev/inmo/tgbotapi/requests/abstracts/Request;Ljava/util/List;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;
@@ -503,6 +507,7 @@ public final class dev/inmo/tgbotapi/bot/ktor/middlewares/TelegramBotMiddlewareB
 	public final fun doOnBeforeCallFactoryMakeCall (Lkotlin/jvm/functions/Function3;)V
 	public final fun doOnBeforeSearchCallFactory (Lkotlin/jvm/functions/Function3;)V
 	public final fun doOnRequestException (Lkotlin/jvm/functions/Function3;)V
+	public final fun doOnRequestExceptionInLimiter (Lkotlin/jvm/functions/Function3;)V
 	public final fun doOnRequestResultAbsent (Lkotlin/jvm/functions/Function3;)V
 	public final fun doOnRequestResultPresented (Lkotlin/jvm/functions/Function5;)V
 	public final fun doOnRequestReturnResult (Lkotlin/jvm/functions/Function4;)V
@@ -511,6 +516,7 @@ public final class dev/inmo/tgbotapi/bot/ktor/middlewares/TelegramBotMiddlewareB
 	public final fun getOnBeforeCallFactoryMakeCall ()Lkotlin/jvm/functions/Function3;
 	public final fun getOnBeforeSearchCallFactory ()Lkotlin/jvm/functions/Function3;
 	public final fun getOnRequestException ()Lkotlin/jvm/functions/Function3;
+	public final fun getOnRequestExceptionInLimiter ()Lkotlin/jvm/functions/Function3;
 	public final fun getOnRequestResultAbsent ()Lkotlin/jvm/functions/Function3;
 	public final fun getOnRequestResultPresented ()Lkotlin/jvm/functions/Function5;
 	public final fun getOnRequestReturnResult ()Lkotlin/jvm/functions/Function4;
@@ -519,6 +525,7 @@ public final class dev/inmo/tgbotapi/bot/ktor/middlewares/TelegramBotMiddlewareB
 	public final fun setOnBeforeCallFactoryMakeCall (Lkotlin/jvm/functions/Function3;)V
 	public final fun setOnBeforeSearchCallFactory (Lkotlin/jvm/functions/Function3;)V
 	public final fun setOnRequestException (Lkotlin/jvm/functions/Function3;)V
+	public final fun setOnRequestExceptionInLimiter (Lkotlin/jvm/functions/Function3;)V
 	public final fun setOnRequestResultAbsent (Lkotlin/jvm/functions/Function3;)V
 	public final fun setOnRequestResultPresented (Lkotlin/jvm/functions/Function5;)V
 	public final fun setOnRequestReturnResult (Lkotlin/jvm/functions/Function4;)V
@@ -537,6 +544,7 @@ public final class dev/inmo/tgbotapi/bot/ktor/middlewares/TelegramBotMiddlewares
 	public fun onBeforeCallFactoryMakeCall (Ldev/inmo/tgbotapi/requests/abstracts/Request;Ldev/inmo/tgbotapi/bot/ktor/KtorCallFactory;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;
 	public fun onBeforeSearchCallFactory (Ldev/inmo/tgbotapi/requests/abstracts/Request;Ljava/util/List;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;
 	public fun onRequestException (Ldev/inmo/tgbotapi/requests/abstracts/Request;Ljava/lang/Throwable;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;
+	public fun onRequestExceptionInLimiter (Ldev/inmo/tgbotapi/requests/abstracts/Request;Ljava/lang/Throwable;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;
 	public fun onRequestResultAbsent (Ldev/inmo/tgbotapi/requests/abstracts/Request;Ljava/util/List;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;
 	public fun onRequestResultPresented (Ljava/lang/Object;Ldev/inmo/tgbotapi/requests/abstracts/Request;Ldev/inmo/tgbotapi/bot/ktor/KtorCallFactory;Ljava/util/List;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;
 	public fun onRequestReturnResult-3t6e044 (Ljava/lang/Object;Ldev/inmo/tgbotapi/requests/abstracts/Request;Ljava/util/List;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;
@@ -10646,6 +10654,7 @@ public final class dev/inmo/tgbotapi/types/CommonKt {
 	public static final field yShiftField Ljava/lang/String;
 	public static final field yearField Ljava/lang/String;
 	public static final fun getAllowedConnectionsLength ()Lkotlin/ranges/IntRange;
+	public static final fun getAllowedConnectionsWithLocalServerLength ()Lkotlin/ranges/IntRange;
 	public static final fun getBasketballAndFootballDiceResultLimit ()Lkotlin/ranges/IntRange;
 	public static final fun getBotCommandDescriptionLimit ()Lkotlin/ranges/IntRange;
 	public static final fun getBotCommandLengthLimit ()Lkotlin/ranges/IntRange;
@@ -31903,6 +31912,16 @@ public final class dev/inmo/tgbotapi/utils/CausedByCancellationKt {
 	public static final fun isCausedByCancellation (Ljava/lang/Throwable;)Z
 }
 
+public final class dev/inmo/tgbotapi/utils/CausedByKt {
+	public static final fun causedBy (Ljava/lang/Throwable;Lkotlin/reflect/KClass;Lkotlin/jvm/functions/Function1;)Ljava/lang/Throwable;
+	public static synthetic fun causedBy$default (Ljava/lang/Throwable;Lkotlin/reflect/KClass;Lkotlin/jvm/functions/Function1;ILjava/lang/Object;)Ljava/lang/Throwable;
+}
+
+public final class dev/inmo/tgbotapi/utils/CausedByUnresolvedAddressExceptionKt {
+	public static final fun causedUnresolvedAddressException (Ljava/lang/Throwable;)Ljava/nio/channels/UnresolvedAddressException;
+	public static final fun isCausedUnresolvedAddressException (Ljava/lang/Throwable;)Z
+}
+
 public final class dev/inmo/tgbotapi/utils/DefaultKSLogKt {
 	public static final fun SetDefaultKTgBotAPIKSLog (ZLkotlin/jvm/functions/Function1;)V
 	public static synthetic fun SetDefaultKTgBotAPIKSLog$default (ZLkotlin/jvm/functions/Function1;ILjava/lang/Object;)V

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/bot/ktor/TelegramBotPipelinesHandler.kt

@@ -3,9 +3,24 @@ package dev.inmo.tgbotapi.bot.ktor
 import dev.inmo.tgbotapi.requests.abstracts.Request
 
 interface TelegramBotPipelinesHandler {
+    /**
+     * Will be called when any exception will happen due to the [request] handling inside of limiter block. This method
+     * will be called for each exception happened during call factory call
+     */
+    suspend fun <T: Any> onRequestExceptionInLimiter(
+        request: Request<T>,
+        t: Throwable
+    ): T? = null
+
     /**
      * Will be called when any exception will happen due to the [request] handling. If returns value - that value
-     * will be returned from [dev.inmo.tgbotapi.bot.RequestsExecutor.execute] instead
+     * will be returned from [dev.inmo.tgbotapi.bot.RequestsExecutor.execute] instead. In difference with
+     * [onRequestExceptionInLimiter], this method will be called only AFTER
+     * [dev.inmo.tgbotapi.bot.settings.limiters.RequestLimiter] will pass result of call factory execution outside of
+     * its [dev.inmo.tgbotapi.bot.settings.limiters.RequestLimiter.limit] function
+     *
+     * @see dev.inmo.tgbotapi.bot.ktor.base.DefaultKtorRequestsExecutor
+     * @see dev.inmo.tgbotapi.bot.settings.limiters.ExceptionsOnlyLimiter
      */
     suspend fun <T: Any> onRequestException(
         request: Request<T>,

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/bot/ktor/base/DefaultKtorRequestsExecutor.kt

@@ -53,29 +53,33 @@ class DefaultKtorRequestsExecutor internal constructor(
             logger.v { "Start request $request" }
             pipelineStepsHolder.onBeforeSearchCallFactory(request, callsFactories)
             requestsLimiter.limit(request) {
-                var result: T? = null
-                lateinit var factoryHandledRequest: KtorCallFactory
-                for (potentialFactory in callsFactories) {
-                    pipelineStepsHolder.onBeforeCallFactoryMakeCall(request, potentialFactory)
-                    logger.v { "Trying factory $potentialFactory for $request" }
-                    val resultFromFactory = potentialFactory.makeCall(
-                        client,
-                        telegramAPIUrlsKeeper,
-                        request,
-                        jsonFormatter
-                    )
-                    logger.v { "Result of factory $potentialFactory handling $request: $resultFromFactory" }
-                    result = pipelineStepsHolder.onAfterCallFactoryMakeCall(resultFromFactory, request, potentialFactory)
-                    logger.v { "Result of pipeline $pipelineStepsHolder handling $resultFromFactory: $result" }
-                    if (result != null) {
-                        factoryHandledRequest = potentialFactory
-                        break
+                runCatching {
+                    var result: T? = null
+                    lateinit var factoryHandledRequest: KtorCallFactory
+                    for (potentialFactory in callsFactories) {
+                        pipelineStepsHolder.onBeforeCallFactoryMakeCall(request, potentialFactory)
+                        logger.v { "Trying factory $potentialFactory for $request" }
+                        val resultFromFactory = potentialFactory.makeCall(
+                            client,
+                            telegramAPIUrlsKeeper,
+                            request,
+                            jsonFormatter
+                        )
+                        logger.v { "Result of factory $potentialFactory handling $request: $resultFromFactory" }
+                        result = pipelineStepsHolder.onAfterCallFactoryMakeCall(resultFromFactory, request, potentialFactory)
+                        logger.v { "Result of pipeline $pipelineStepsHolder handling $resultFromFactory: $result" }
+                        if (result != null) {
+                            factoryHandledRequest = potentialFactory
+                            break
+                        }
                     }
-                }
 
-                result ?.let {
-                    pipelineStepsHolder.onRequestResultPresented(it, request, factoryHandledRequest, callsFactories)
-                } ?: pipelineStepsHolder.onRequestResultAbsent(request, callsFactories) ?: error("Can't execute request: $request")
+                    result ?.let {
+                        pipelineStepsHolder.onRequestResultPresented(it, request, factoryHandledRequest, callsFactories)
+                    } ?: pipelineStepsHolder.onRequestResultAbsent(request, callsFactories) ?: error("Can't execute request: $request")
+                }.onFailure { e ->
+                    pipelineStepsHolder.onRequestExceptionInLimiter(request, e) ?.let { return@let it } ?: throw e
+                }.getOrThrow()
             }
         }.let {
             val result = it.exceptionOrNull() ?.let { e ->

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/bot/ktor/middlewares/TelegramBotMiddleware.kt

@@ -31,9 +31,16 @@ open class TelegramBotMiddleware(
     internal val onRequestResultPresented: (suspend (result: Any, request: Request<*>, resultCallFactory: KtorCallFactory, callsFactories: List<KtorCallFactory>) -> Any?)? = null,
     internal val onRequestResultAbsent: (suspend (request: Request<*>, callsFactories: List<KtorCallFactory>) -> Any?)? = null,
     internal val onRequestReturnResult: (suspend (result: Result<*>, request: Request<*>, callsFactories: List<KtorCallFactory>) -> Result<Any?>?)? = null,
+    internal val onRequestExceptionInLimiter: (suspend (request: Request<*>, t: Throwable?) -> Any?)? = null,
     val id: String = uuid4().toString()
 ) : TelegramBotPipelinesHandler {
     object ResultAbsence : Throwable()
+
+    override suspend fun <T : Any> onRequestExceptionInLimiter(request: Request<T>, t: Throwable): T? {
+        @Suppress("UNCHECKED_CAST")
+        return onRequestExceptionInLimiter ?.invoke(request, t) as? T
+    }
+
     override suspend fun <T : Any> onRequestException(request: Request<T>, t: Throwable): T? {
         @Suppress("UNCHECKED_CAST")
         return onRequestException ?.invoke(request, t) as? T

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/bot/ktor/middlewares/TelegramBotMiddlewareBuilder.kt

@@ -8,6 +8,7 @@ import dev.inmo.tgbotapi.requests.abstracts.Request
 
 @Warning("This API is experimental and subject of changes")
 class TelegramBotMiddlewareBuilder {
+    var onRequestExceptionInLimiter: (suspend (request: Request<*>, t: Throwable?) -> Any?)? = null
     var onRequestException: (suspend (request: Request<*>, t: Throwable?) -> Any?)? = null
     var onBeforeSearchCallFactory: (suspend (request: Request<*>, callsFactories: List<KtorCallFactory>) -> Unit)? = null
     var onBeforeCallFactoryMakeCall: (suspend (request: Request<*>, potentialFactory: KtorCallFactory) -> Unit)? = null
@@ -17,6 +18,12 @@ class TelegramBotMiddlewareBuilder {
     var onRequestReturnResult: (suspend (result: Result<*>, request: Request<*>, callsFactories: List<KtorCallFactory>) -> Result<Any?>?)? = null
     var id: String = uuid4().toString()
 
+    /**
+     * Useful way to set [onRequestException]
+     */
+    fun doOnRequestExceptionInLimiter(block: suspend (request: Request<*>, t: Throwable?) -> Any?) {
+        onRequestExceptionInLimiter = block
+    }
     /**
      * Useful way to set [onRequestException]
      */
@@ -63,6 +70,7 @@ class TelegramBotMiddlewareBuilder {
     @Warning("This API is experimental and subject of changes")
     fun build(): TelegramBotMiddleware {
         return TelegramBotMiddleware(
+            onRequestExceptionInLimiter = onRequestExceptionInLimiter,
             onRequestException = onRequestException,
             onBeforeSearchCallFactory = onBeforeSearchCallFactory,
             onBeforeCallFactoryMakeCall = onBeforeCallFactoryMakeCall,
@@ -78,6 +86,7 @@ class TelegramBotMiddlewareBuilder {
         @Warning("This API is experimental and subject of changes")
         fun from(middleware: TelegramBotMiddleware, additionalSetup: TelegramBotMiddlewareBuilder.() -> Unit): TelegramBotMiddleware {
             return TelegramBotMiddlewareBuilder().apply {
+                onRequestExceptionInLimiter = middleware.onRequestExceptionInLimiter
                 onRequestException = middleware.onRequestException
                 onBeforeSearchCallFactory = middleware.onBeforeSearchCallFactory
                 onBeforeCallFactoryMakeCall = middleware.onBeforeCallFactoryMakeCall

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/bot/ktor/middlewares/TelegramBotMiddlewaresPipelinesHandler.kt

@@ -10,6 +10,12 @@ import dev.inmo.tgbotapi.requests.abstracts.Request
 class TelegramBotMiddlewaresPipelinesHandler(
     private val middlewares: List<TelegramBotMiddleware> = emptyList()
 ) : TelegramBotPipelinesHandler {
+    override suspend fun <T : Any> onRequestExceptionInLimiter(request: Request<T>, t: Throwable): T? {
+        return middlewares.firstNotNullOfOrNull {
+            it.onRequestExceptionInLimiter(request, t)
+        } ?: super.onRequestExceptionInLimiter(request, t)
+    }
+
     override suspend fun <T : Any> onRequestException(request: Request<T>, t: Throwable): T? {
         return middlewares.firstNotNullOfOrNull {
             it.onRequestException(request, t)

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/bot/settings/limiters/ExceptionsOnlyLimiter.kt

@@ -1,6 +1,8 @@
 package dev.inmo.tgbotapi.bot.settings.limiters
 
 import dev.inmo.tgbotapi.bot.exceptions.TooMuchRequestsException
+import dev.inmo.tgbotapi.utils.isCausedUnresolvedAddressException
+import io.ktor.util.network.UnresolvedAddressException
 import kotlinx.coroutines.delay
 
 /**
@@ -13,10 +15,10 @@ object ExceptionsOnlyLimiter : RequestLimiter {
             result = runCatching {
                 block()
             }.onFailure {
-                if (it is TooMuchRequestsException) {
-                    delay(it.retryAfter.leftToRetry)
-                } else {
-                    throw it
+                when {
+                    it.isCausedUnresolvedAddressException() -> delay(1000L)
+                    it is TooMuchRequestsException -> delay(it.retryAfter.leftToRetry)
+                    else -> throw it
                 }
             }
         }

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/requests/webhook/SetWebhook.kt

@@ -1,9 +1,11 @@
 package dev.inmo.tgbotapi.requests.webhook
 
+import dev.inmo.kslog.common.w
 import dev.inmo.tgbotapi.requests.abstracts.*
 import dev.inmo.tgbotapi.requests.send.media.base.DataRequest
 import dev.inmo.tgbotapi.requests.send.media.base.MultipartRequestImpl
 import dev.inmo.tgbotapi.types.*
+import dev.inmo.tgbotapi.utils.DefaultKTgBotAPIKSLog
 import kotlinx.serialization.*
 import kotlinx.serialization.builtins.serializer
 
@@ -118,11 +120,22 @@ fun SetWebhook(
 )
 
 /**
- * Use this method to specify a url and receive incoming updates via an outgoing webhook. Whenever there is an update
- * for the bot, we will send an HTTPS POST request to the specified url, containing a JSON-serialized Update.
+ * Represents a request for setting a webhook in Telegram's Bot API. A webhook allows Telegram to send updates directly
+ * to the bot via an HTTPS POST request to the provided URL, enabling real-time interaction.
  *
- * If you'd like to make sure that the Webhook request comes from Telegram, we recommend using a secret path in the [url],
- * e.g. https://www.example.com/<token>. Since nobody else knows your bot's token, you can be pretty sure it's us.
+ * @constructor Creates a data class holding configuration options for the webhook.
+ *
+ * @property url The HTTPS URL to which updates will be posted. Must be valid and accessible.
+ * @property certificateFile An optional path to a public certificate file for webhook verification. Use only if a self-signed certificate is applied.
+ * @property ipAddress The fixed IP address for incoming webhook connections.
+ * @property maxAllowedConnections The maximum number of simultaneous HTTPS connections allowed to the webhook for
+ * delivering updates. You may use value outside of [allowedConnectionsLength], but be sure that it is in
+ * [allowedConnectionsWithLocalServerLength] and you are using local bot api url
+ * @property allowedUpdates A list of update types the bot will receive. Defaults to all update types.
+ * @property dropPendingUpdates If true, all pending updates will be dropped when the webhook is changed.
+ * @property secretToken An optional arbitrary secret key to ensure the webhook updates are coming from Telegram.
+ *
+ * @throws IllegalArgumentException if the provided maxAllowedConnections value is outside the permitted range (both [allowedConnectionsLength] and [allowedConnectionsWithLocalServerLength])
  */
 @ConsistentCopyVisibility
 @Serializable
@@ -150,8 +163,19 @@ data class SetWebhook internal constructor(
 
     init {
         maxAllowedConnections ?.let {
-            if (it !in allowedConnectionsLength) {
-                throw IllegalArgumentException("Allowed connection for webhook must be in $allowedConnectionsLength range (but passed $it)")
+            when {
+                it !in allowedConnectionsLength && it in allowedConnectionsWithLocalServerLength -> {
+                    DefaultKTgBotAPIKSLog.w {
+                        """
+                            Passed amount of allowed connections to server is $it and it exceeds default amount of
+                            connections $allowedConnectionsLength, but can be used with local bot api server. Make sure
+                            you are using local bot api url in your bot.
+                        """.trimIndent()
+                    }
+                }
+                it !in allowedConnectionsLength -> {
+                    throw IllegalArgumentException("Allowed connection for webhook must be in $allowedConnectionsLength range (but passed $it)")
+                }
             }
         }
     }

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/types/Common.kt

@@ -64,6 +64,7 @@ val threadNameLength = 1 until 128
 val chatDescriptionLength = 0 until 256
 val inlineResultQueryIdLingth = 1 until 64
 val allowedConnectionsLength = 1 .. 100
+val allowedConnectionsWithLocalServerLength = 1 .. 100000
 
 val invoiceTitleLimit = 1 until 32
 val invoiceDescriptionLimit = 1 until 256

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/utils/CausedBy.kt

@@ -0,0 +1,15 @@
+package dev.inmo.tgbotapi.utils
+
+import kotlin.reflect.KClass
+
+fun <T : Throwable> Throwable.causedBy(kclass: KClass<T>, additionalFilterOnHappened: (T) -> T? = { it }): T? {
+    var current = this
+    while (kclass.isInstance(current) == false) {
+        when {
+            kclass.isInstance(current) -> return additionalFilterOnHappened(current as T)
+            else -> current = current.cause ?: return null
+        }
+    }
+
+    return current as T
+}

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/utils/CausedByCancellation.kt

@@ -14,16 +14,9 @@ import kotlinx.coroutines.CancellationException
  * @return the first [CancellationException] found in the cause chain, or `null` if none present
  */
 fun Throwable.causedCancellationException(): CancellationException? {
-    var current = this
-    while (current !is CancellationException) {
-        when {
-            // It is possible, that API will be changed and cancellation will be caused by something else
-            current is CancellationException && current.cause == null -> return current
-            else -> current = current.cause ?: return null
-        }
+    return causedBy(CancellationException::class) {
+        it.takeIf { it.cause == null }
     }
-
-    return current
 }
 
 /**

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/utils/CausedByUnresolvedAddressException.kt

@@ -0,0 +1,9 @@
+package dev.inmo.tgbotapi.utils
+
+import io.ktor.util.network.UnresolvedAddressException
+
+fun Throwable.causedUnresolvedAddressException(): UnresolvedAddressException? {
+    return causedBy(UnresolvedAddressException::class)
+}
+
+fun Throwable.isCausedUnresolvedAddressException(): Boolean = causedUnresolvedAddressException() != null

tgbotapi.ksp/src/main/kotlin/TelegramBotAPISymbolProcessor.kt

@@ -8,6 +8,7 @@ import com.squareup.kotlinpoet.FileSpec
 import com.squareup.kotlinpoet.asClassName
 import com.squareup.kotlinpoet.ksp.writeTo
 import dev.inmo.micro_ksp.generator.resolveSubclasses
+import dev.inmo.micro_ksp.generator.withNoSuchElementWorkaround
 import dev.inmo.tgbotapi.types.message.ChatEvents.abstracts.ChatEvent
 import dev.inmo.tgbotapi.utils.RiskFeature
 import dev.inmo.tgbotapi.utils.internal.ClassCastsExcluded
@@ -30,7 +31,9 @@ class TelegramBotAPISymbolProcessor(
         val classes = resolver.getSymbolsWithAnnotation(classCastsIncludedClassName.canonicalName).filterIsInstance<KSClassDeclaration>()
         val classesRegexes: Map<KSClassDeclaration, Pair<Regex?, Regex?>> = classes.mapNotNull {
             it to (it.getAnnotationsByType(ClassCastsIncluded::class).firstNotNullOfOrNull {
-                it.typesRegex.takeIf { it.isNotEmpty() } ?.let(::Regex) to it.excludeRegex.takeIf { it.isNotEmpty() } ?.let(::Regex)
+                val typesRegex = withNoSuchElementWorkaround("") { it.typesRegex }
+                val excludeRegex = withNoSuchElementWorkaround("") { it.excludeRegex }
+                typesRegex.takeIf { it.isNotEmpty() } ?.let(::Regex) to excludeRegex.takeIf { it.isNotEmpty() } ?.let(::Regex)
             } ?: return@mapNotNull null)
         }.toMap()
         val classesSubtypes = mutableMapOf<KSClassDeclaration, MutableSet<KSClassDeclaration>>()

tgbotapi.utils/api/tgbotapi.utils.api

@@ -3705,7 +3705,9 @@ public final class dev/inmo/tgbotapi/extensions/utils/updates/retrieving/LongPol
 	public static synthetic fun longPolling$default (Ldev/inmo/tgbotapi/bot/RequestsExecutor;ILkotlinx/coroutines/CoroutineScope;Lkotlin/jvm/functions/Function2;IZZLjava/lang/Long;Lkotlin/jvm/functions/Function1;ILjava/lang/Object;)Lkotlinx/coroutines/Job;
 	public static synthetic fun longPolling$default (Ldev/inmo/tgbotapi/bot/RequestsExecutor;Ldev/inmo/tgbotapi/updateshandlers/UpdatesFilter;ILkotlinx/coroutines/CoroutineScope;ZZLjava/lang/Long;Lkotlin/jvm/functions/Function2;ILjava/lang/Object;)Lkotlinx/coroutines/Job;
 	public static final fun longPollingFlow (Ldev/inmo/tgbotapi/bot/RequestsExecutor;ILkotlin/jvm/functions/Function2;Ljava/util/List;ZZLjava/lang/Long;)Lkotlinx/coroutines/flow/Flow;
+	public static final fun longPollingFlow (Ldev/inmo/tgbotapi/bot/RequestsExecutor;Lkotlin/jvm/functions/Function2;ZZLjava/lang/Long;Lkotlin/jvm/functions/Function1;)Lkotlinx/coroutines/flow/Flow;
 	public static synthetic fun longPollingFlow$default (Ldev/inmo/tgbotapi/bot/RequestsExecutor;ILkotlin/jvm/functions/Function2;Ljava/util/List;ZZLjava/lang/Long;ILjava/lang/Object;)Lkotlinx/coroutines/flow/Flow;
+	public static synthetic fun longPollingFlow$default (Ldev/inmo/tgbotapi/bot/RequestsExecutor;Lkotlin/jvm/functions/Function2;ZZLjava/lang/Long;Lkotlin/jvm/functions/Function1;ILjava/lang/Object;)Lkotlinx/coroutines/flow/Flow;
 	public static final fun retrieveAccumulatedUpdates (Ldev/inmo/tgbotapi/bot/RequestsExecutor;Ldev/inmo/tgbotapi/updateshandlers/FlowsUpdatesFilter;ZZLkotlinx/coroutines/CoroutineScope;ZLjava/lang/Long;Lkotlin/jvm/functions/Function2;)Lkotlinx/coroutines/Job;
 	public static final fun retrieveAccumulatedUpdates (Ldev/inmo/tgbotapi/bot/RequestsExecutor;ZZLkotlinx/coroutines/CoroutineScope;Lkotlin/jvm/functions/Function2;Ljava/util/List;ZLjava/lang/Long;Lkotlin/jvm/functions/Function2;)Lkotlinx/coroutines/Job;
 	public static synthetic fun retrieveAccumulatedUpdates$default (Ldev/inmo/tgbotapi/bot/RequestsExecutor;Ldev/inmo/tgbotapi/updateshandlers/FlowsUpdatesFilter;ZZLkotlinx/coroutines/CoroutineScope;ZLjava/lang/Long;Lkotlin/jvm/functions/Function2;ILjava/lang/Object;)Lkotlinx/coroutines/Job;

tgbotapi.utils/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/utils/updates/retrieving/LongPolling.kt

@@ -1,6 +1,5 @@
 package dev.inmo.tgbotapi.extensions.utils.updates.retrieving
 
-import dev.inmo.kslog.common.logger
 import dev.inmo.micro_utils.coroutines.*
 import dev.inmo.tgbotapi.bot.RequestsExecutor
 import dev.inmo.tgbotapi.bot.TelegramBot
@@ -15,27 +14,36 @@ import dev.inmo.tgbotapi.types.update.*
 import dev.inmo.tgbotapi.types.update.abstracts.BaseSentMessageUpdate
 import dev.inmo.tgbotapi.types.update.abstracts.Update
 import dev.inmo.tgbotapi.updateshandlers.*
-import dev.inmo.tgbotapi.utils.DefaultKTgBotAPIKSLog
-import dev.inmo.tgbotapi.utils.causedCancellationException
-import dev.inmo.tgbotapi.utils.isCausedByCancellation
+import dev.inmo.tgbotapi.utils.isCausedUnresolvedAddressException
 import dev.inmo.tgbotapi.utils.subscribeWithBotLogger
+import io.ktor.client.network.sockets.ConnectTimeoutException
 import io.ktor.client.plugins.HttpRequestTimeoutException
 import io.ktor.utils.io.CancellationException
 import kotlinx.coroutines.*
 import kotlinx.coroutines.flow.*
 
 /**
- * @param mediaGroupsDebounceTimeMillis Will be used for calling of [updateHandlerWithMediaGroupsAdaptation]. Pass null
- * in case you wish to enable classic way of updates handling, but in that mode some media group messages can be
- * retrieved in different updates
+ * Starts a long polling flow to receive updates continuously from the Telegram Bot API.
+ *
+ * This method retrieves updates from the bot, processes them, and emits them as a flow of `Update` objects.
+ * It allows handling of updates with features like automatic webhook disabling, timeout exception skipping,
+ * and media group handling with debounce time.
+ *
+ * @param exceptionsHandler Optional exception handler to manage exceptions that occur during the polling process.
+ * @param autoDisableWebhooks Specifies whether to automatically disable existing webhooks before starting the long polling flow (default: `true`).
+ * @param autoSkipTimeoutExceptions Defines if timeout-related exceptions should automatically be skipped during the polling (default: `true`).
+ * @param mediaGroupsDebounceTimeMillis The debounce time in milliseconds for processing media group updates.
+ *        If set to `null`, media group handling is disabled (default: `1000L`).
+ * @param getUpdatesRequestCreator A function that creates a `GetUpdates` request for retrieving updates.
+ *        This function accepts the identifier of the most recent update as an input and returns the new request.
+ * @return A [Flow] of [Update] objects that represents the continuous stream of updates received.
  */
 fun TelegramBot.longPollingFlow(
-    timeoutSeconds: Seconds = 30,
     exceptionsHandler: (ExceptionHandler<Unit>)? = null,
-    allowedUpdates: List<String>? = ALL_UPDATES_LIST,
     autoDisableWebhooks: Boolean = true,
     autoSkipTimeoutExceptions: Boolean = true,
     mediaGroupsDebounceTimeMillis: Long? = 1000L,
+    getUpdatesRequestCreator: (sinceUpdate: UpdateId?) -> GetUpdates
 ): Flow<Update> = channelFlow {
     if (autoDisableWebhooks) {
         runCatchingLogging(logger = Log) {
@@ -116,23 +124,23 @@ fun TelegramBot.longPollingFlow(
         while (isActive) {
             runCatchingLogging(logger = Log) {
                 execute(
-                    GetUpdates(
-                        offset = lastUpdateIdentifier?.plus(1),
-                        timeout = timeoutSeconds,
-                        allowed_updates = allowedUpdates
-                    )
+                    getUpdatesRequestCreator(lastUpdateIdentifier ?.plus(1))
                 ).let { originalUpdates ->
                     updatesHandler(originalUpdates)
                 }
             }.onFailure { e ->
                 runCatchingLogging(logger = Log) {
                     val isHttpRequestTimeoutException =
-                        e is HttpRequestTimeoutException || (e is CommonBotException && e.cause is HttpRequestTimeoutException)
+                        e is ConnectTimeoutException || e is HttpRequestTimeoutException || (e is CommonBotException && e.cause is HttpRequestTimeoutException)
                     if (isHttpRequestTimeoutException && autoSkipTimeoutExceptions) {
                         return@onFailure
                     }
+
                     exceptionsHandler?.invoke(e)
-                    if (e is RequestException) {
+
+                    // It seems some problems with internet connection. See https://github.com/InsanusMokrassar/ktgbotapi/issues/989
+                    val isUnresolvedAddressException = e.isCausedUnresolvedAddressException()
+                    if (e is RequestException || isUnresolvedAddressException) {
                         delay(1000L)
                     }
                 }
@@ -141,6 +149,45 @@ fun TelegramBot.longPollingFlow(
     }
 }
 
+/**
+ * Initiates a long polling flow for receiving updates continuously from the Telegram Bot API.
+ * This method provides a customized way to handle the retrieval of updates with options
+ * to configure timeouts, update types, exception handling, and media group processing.
+ *
+ * @param timeoutSeconds The maximum time in seconds for the server to wait for available updates
+ * before responding (default: `30`).
+ * @param exceptionsHandler An optional exception handler for managing exceptions that occur during the
+ * long polling process. If not provided, exceptions will pass through unhandled.
+ * @param allowedUpdates A list of the update types to retrieve. By default, retrieves all possible
+ * update types as defined in `ALL_UPDATES_LIST`.
+ * @param autoDisableWebhooks Whether the current webhook should be disabled automatically before starting the
+ * long polling flow (default: `true`).
+ * @param autoSkipTimeoutExceptions Determines if timeout-related exceptions should be automatically skipped
+ * during the polling process (default: `true`).
+ * @param mediaGroupsDebounceTimeMillis The debounce time in milliseconds for processing updates containing
+ * media groups. If set to `null`, media group handling is disabled (default: `1000L`).
+ * @return A Flow that emits Update objects representing the updates fetched from the Telegram Bot API.
+ */
+fun TelegramBot.longPollingFlow(
+    timeoutSeconds: Seconds = 30,
+    exceptionsHandler: (ExceptionHandler<Unit>)? = null,
+    allowedUpdates: List<String>? = ALL_UPDATES_LIST,
+    autoDisableWebhooks: Boolean = true,
+    autoSkipTimeoutExceptions: Boolean = true,
+    mediaGroupsDebounceTimeMillis: Long? = 1000L,
+): Flow<Update> = longPollingFlow(
+    exceptionsHandler = exceptionsHandler,
+    autoDisableWebhooks = autoDisableWebhooks,
+    autoSkipTimeoutExceptions = autoSkipTimeoutExceptions,
+    mediaGroupsDebounceTimeMillis = mediaGroupsDebounceTimeMillis,
+) {
+    GetUpdates(
+        offset = it,
+        timeout = timeoutSeconds,
+        allowed_updates = allowedUpdates
+    )
+}
+
 /**
  * @param mediaGroupsDebounceTimeMillis Will be used for calling of [updateHandlerWithMediaGroupsAdaptation]. Pass null
  * in case you wish to enable classic way of updates handling, but in that mode some media group messages can be