Update ktor monorepo to v3.4.2

BusinessConnectionsBot/src/main/kotlin/BusinessConnectionsBot.kt

@@ -3,7 +3,6 @@ import dev.inmo.kslog.common.LogLevel
 import dev.inmo.kslog.common.defaultMessageFormatter
 import dev.inmo.kslog.common.setDefaultKSLog
 import dev.inmo.micro_utils.common.Percentage
-import dev.inmo.tgbotapi.types.chat.PreviewBot
 import dev.inmo.tgbotapi.extensions.api.answers.answer
 import dev.inmo.tgbotapi.extensions.api.bot.getMe
 import dev.inmo.tgbotapi.extensions.api.business.getBusinessAccountStarBalance
@@ -28,8 +27,7 @@ import dev.inmo.tgbotapi.extensions.api.stories.deleteStory
 import dev.inmo.tgbotapi.extensions.api.stories.postStory
 import dev.inmo.tgbotapi.extensions.behaviour_builder.telegramBotWithBehaviourAndLongPolling
 import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.*
-import dev.inmo.tgbotapi.extensions.utils.chatContentMessageOrNull
+import dev.inmo.tgbotapi.extensions.utils.commonMessageOrNull
-import dev.inmo.tgbotapi.extensions.utils.chatMessageOrNull
 import dev.inmo.tgbotapi.extensions.utils.extendedPrivateChatOrThrow
 import dev.inmo.tgbotapi.extensions.utils.ifAccessibleMessage
 import dev.inmo.tgbotapi.extensions.utils.ifBusinessContentMessage
@@ -46,15 +44,13 @@ import dev.inmo.tgbotapi.types.MessageId
 import dev.inmo.tgbotapi.types.RawChatId
 import dev.inmo.tgbotapi.types.business_connection.BusinessConnectionId
 import dev.inmo.tgbotapi.types.chat.PrivateChat
-import dev.inmo.tgbotapi.types.message.abstracts.ChatContentMessage
+import dev.inmo.tgbotapi.types.message.abstracts.CommonMessage
-import dev.inmo.tgbotapi.types.message.content.LivePhotoContent
 import dev.inmo.tgbotapi.types.message.content.PhotoContent
 import dev.inmo.tgbotapi.types.message.content.StoryContent
 import dev.inmo.tgbotapi.types.message.content.TextContent
 import dev.inmo.tgbotapi.types.message.content.VideoContent
 import dev.inmo.tgbotapi.types.message.content.VisualMediaGroupPartContent
 import dev.inmo.tgbotapi.types.stories.InputStoryContent
-import dev.inmo.tgbotapi.types.stories.InputStoryContent.*
 import dev.inmo.tgbotapi.types.stories.StoryArea
 import dev.inmo.tgbotapi.types.stories.StoryAreaPosition
 import dev.inmo.tgbotapi.types.stories.StoryAreaType
@@ -124,15 +120,6 @@ suspend fun main(args: Array<String>) {
                 if (businessContentMessage.sentByBusinessConnectionOwner) {
                     reply(sent, "You have sent this message to the ${businessContentMessage.businessConnectionId.string} related chat")
                 } else {
-                    // Since TG Bot API 9.0: business bots can reply to other bots in business context
-                    // when bot-to-bot communication is enabled for both bots
-                    if (businessContentMessage.from is PreviewBot) {
-                        reply(
-                            to = sent,
-                            text = "Replying to bot ${businessContentMessage.from.firstName} in business context (bot-to-bot reply)",
-                        )
-                        return@ifBusinessContentMessage
-                    }
                     reply(
                         to = sent,
                         text = "User have sent this message to you in the ${businessContentMessage.businessConnectionId.string} related chat",
@@ -216,8 +203,6 @@ suspend fun main(args: Array<String>) {
                 }
             )
         }
-        // Since TG Bot API 9.0: the following account management commands no longer require
-        // the connected user to have a Telegram Premium subscription.
         onCommandWithArgs("set_business_account_name", initialFilter = { it.chat is PrivateChat }) { it, args ->
             val firstName = args[0]
             val secondName = args.getOrNull(1)
@@ -364,9 +349,9 @@ suspend fun main(args: Array<String>) {
                 }
             }
         }
-        suspend fun handleSetProfilePhoto(it: ChatContentMessage<TextContent>, isPublic: Boolean) {
+        suspend fun handleSetProfilePhoto(it: CommonMessage<TextContent>, isPublic: Boolean) {
             val businessConnectionId = chatsBusinessConnections[it.chat.id] ?: return@handleSetProfilePhoto
-            val replyTo = it.replyTo ?.chatContentMessageOrNull() ?.withContentOrNull<PhotoContent>()
+            val replyTo = it.replyTo ?.commonMessageOrNull() ?.withContentOrNull<PhotoContent>()
             if (replyTo == null) {
                 reply(it) {
                     +"Reply to photo for using of this command"
@@ -426,7 +411,7 @@ suspend fun main(args: Array<String>) {
 
         onCommand("post_story", initialFilter = { it.chat is PrivateChat }) {
             val businessConnectionId = chatsBusinessConnections[it.chat.id] ?: return@onCommand
-            val replyTo = it.replyTo ?.chatContentMessageOrNull() ?.withContentOrNull<VisualMediaGroupPartContent>()
+            val replyTo = it.replyTo ?.commonMessageOrNull() ?.withContentOrNull<VisualMediaGroupPartContent>()
             if (replyTo == null) {
                 reply(it) {
                     +"Reply to photo or video for using of this command"
@@ -439,16 +424,12 @@ suspend fun main(args: Array<String>) {
                 postStory(
                     businessConnectionId,
                     when (replyTo.content) {
-                        is PhotoContent -> Photo(
+                        is PhotoContent -> InputStoryContent.Photo(
                             file.multipartFile()
                         )
-                        is VideoContent -> Video(
+                        is VideoContent -> InputStoryContent.Video(
                             file.multipartFile()
                         )
-                        is LivePhotoContent -> Video(
-                            file.multipartFile(),
-                            isAnimation = true
-                        )
                     },
                     activePeriod = PostStory.ACTIVE_PERIOD_6_HOURS,
                     areas = listOf(
@@ -484,7 +465,7 @@ suspend fun main(args: Array<String>) {
 
         onCommand("delete_story", initialFilter = { it.chat is PrivateChat }) {
             val businessConnectionId = chatsBusinessConnections[it.chat.id] ?: return@onCommand
-            val replyTo = it.replyTo ?.chatContentMessageOrNull() ?.withContentOrNull<StoryContent>()
+            val replyTo = it.replyTo ?.commonMessageOrNull() ?.withContentOrNull<StoryContent>()
             if (replyTo == null) {
                 reply(it) {
                     +"Reply to photo or video for using of this command"

ChatManagementBot/build.gradle

@@ -1,21 +0,0 @@
-buildscript {
-    repositories {
-        mavenCentral()
-    }
-
-    dependencies {
-        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
-    }
-}
-
-apply plugin: 'kotlin'
-apply plugin: 'application'
-
-mainClassName="ChatManagementBotKt"
-
-
-dependencies {
-    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
-
-    implementation "dev.inmo:tgbotapi:$telegram_bot_api_version"
-}

ChatManagementBot/src/main/kotlin/ChatManagementBot.kt

@@ -1,146 +0,0 @@
-import dev.inmo.kslog.common.KSLog
-import dev.inmo.kslog.common.LogLevel
-import dev.inmo.kslog.common.defaultMessageFormatter
-import dev.inmo.kslog.common.setDefaultKSLog
-import dev.inmo.tgbotapi.extensions.api.bot.getMe
-import dev.inmo.tgbotapi.extensions.api.chat.get.getChatAdministrators
-import dev.inmo.tgbotapi.extensions.api.send.deleteAllUserMessageReactions
-import dev.inmo.tgbotapi.extensions.api.send.deleteUserMessageReaction
-import dev.inmo.tgbotapi.extensions.api.send.reply
-import dev.inmo.tgbotapi.extensions.behaviour_builder.filters.chatMemberGotRestrictedFilter
-import dev.inmo.tgbotapi.extensions.behaviour_builder.filters.chatMemberGotRestrictionsChangedFilter
-import dev.inmo.tgbotapi.extensions.behaviour_builder.telegramBotWithBehaviourAndLongPolling
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onChatMemberUpdated
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onCommand
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onContentMessage
-import dev.inmo.tgbotapi.extensions.behaviour_builder.utils.plus
-import dev.inmo.tgbotapi.extensions.utils.chatContentMessageOrNull
-import dev.inmo.tgbotapi.extensions.utils.contentMessageOrNull
-import dev.inmo.tgbotapi.extensions.utils.fromUserChatMessageOrNull
-import dev.inmo.tgbotapi.extensions.utils.fromUserMessageOrNull
-import dev.inmo.tgbotapi.extensions.utils.publicChatOrNull
-import dev.inmo.tgbotapi.extensions.utils.restrictedMemberChatMemberOrNull
-import dev.inmo.tgbotapi.types.chat.CommonBot
-import dev.inmo.tgbotapi.types.chat.ChatPermissions
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-
-/**
- * This bot demonstrates Chat Management API features added in Bot API 9.x:
- *
- * 1. `can_react_to_messages` field in `ChatMemberRestricted` — printed when a member's
- *    restrictions are changed (requires the bot to be an admin in the group).
- *    `RestrictedMemberChatMember` also implements `ChatPermissions`, so the same field
- *    covers both `ChatMemberRestricted` and `ChatPermissions` from the spec.
- *
- * 2. `return_bots` in `getChatAdministrators` — `/admins` command lists all admins
- *    including other bots (retrieveOtherBots = true).
- *
- * 3. `deleteAllMessageReactions` — `/deleteallreactions` in reply to a message removes
- *    all reactions that the replied message's author has left across the entire chat.
- *
- * 4. `deleteMessageReaction` — `/deletereaction` in reply to a message removes the
- *    reaction the replied message's author placed on that specific message.
- *
- * 5. Seeing messages from other bots in groups — demonstrated via `canReadAllGroupMessages`
- *    from `getMe()`. When true (privacy mode off), the bot receives messages from other bots.
- *    All such messages are logged.
- *
- * Usage: pass the bot token as the first argument. Optional: `debug`, `testServer`.
- */
-suspend fun main(vararg args: String) {
-    val botToken = args.first()
-    val isDebug = args.any { it == "debug" }
-    val isTestServer = args.any { it == "testServer" }
-
-    if (isDebug) {
-        setDefaultKSLog(
-            KSLog { level: LogLevel, tag: String?, message: Any, throwable: Throwable? ->
-                println(defaultMessageFormatter(level, tag, message, throwable))
-            }
-        )
-    }
-
-    telegramBotWithBehaviourAndLongPolling(
-        botToken,
-        CoroutineScope(Dispatchers.IO),
-        testServer = isTestServer
-    ) {
-        val me = getMe()
-        println("Bot: ${me.firstName} (@${me.username?.username})")
-
-        // Feature 5: canReadAllGroupMessages (can_read_all_group_messages) from getMe()
-        // When true, the bot receives messages from other bots in groups (privacy mode off)
-        println("canReadAllGroupMessages: ${me.canReadAllGroupMessages}")
-
-        // Feature 1: can_react_to_messages in ChatMemberRestricted and ChatPermissions
-        // RestrictedMemberChatMember implements ChatPermissions, so canReactToMessages
-        // appears in both types as required by the Telegram Bot API spec
-        onChatMemberUpdated(
-            initialFilter = chatMemberGotRestrictedFilter + chatMemberGotRestrictionsChangedFilter
-        ) { update ->
-            val restricted = update.newChatMemberState.restrictedMemberChatMemberOrNull()
-                ?: return@onChatMemberUpdated
-            println("Restriction update for ${update.member.firstName}:")
-            // canReactToMessages as ChatMemberRestricted field
-            println("  canReactToMessages (ChatMemberRestricted): ${restricted.canReactToMessages}")
-            // same field via ChatPermissions — RestrictedMemberChatMember : ChatPermissions
-            val permissions: ChatPermissions = restricted
-            println("  canReactToMessages (ChatPermissions):      ${permissions.canReactToMessages}")
-        }
-
-        // Feature 2: return_bots parameter in getChatAdministrators
-        // retrieveOtherBots = true corresponds to return_bots = true in the Telegram API
-        onCommand("admins") { message ->
-            val chat = message.chat.publicChatOrNull() ?: run {
-                reply(message) { +"This command works only in groups/supergroups/channels" }
-                return@onCommand
-            }
-            val admins = getChatAdministrators(chat, retrieveOtherBots = true)
-            reply(message) {
-                +"Administrators (retrieveOtherBots=true, includes bots):\n"
-                admins.forEach { admin ->
-                    val kind = if (admin.user is CommonBot) "bot" else "user"
-                    +"• ${admin.user.firstName} [$kind]\n"
-                }
-            }
-        }
-
-        // Feature 4: deleteMessageReaction
-        // Deletes a specific reaction by the replied message's author on that message
-        onCommand("deletereaction") { message ->
-            val replied = message.replyTo ?.fromUserChatMessageOrNull() ?: run {
-                reply(message) { +"Reply to a message to remove that user's reaction from it" }
-                return@onCommand
-            }
-            deleteUserMessageReaction(replied, replied.user.id)
-            reply(message) { +"Deleted reaction by ${replied.user.firstName} on the replied message" }
-        }
-
-        // Feature 3: deleteAllMessageReactions
-        // Deletes all reactions that the replied message's author has left in this chat
-        onCommand("deleteallreactions") { message ->
-            val replied = message.replyTo?.fromUserMessageOrNull() ?: run {
-                reply(message) { +"Reply to a message to clear all reactions of that user in this chat" }
-                return@onCommand
-            }
-            deleteAllUserMessageReactions(message.chat, replied.user.id)
-            reply(message) { +"Deleted all reactions by ${replied.user.firstName} in this chat" }
-        }
-
-        // Feature 5: messages from other bots in groups
-        // Bots with canReadAllGroupMessages=true (privacy mode off) receive messages from other bots.
-        // This handler logs all such messages to demonstrate the feature.
-        onContentMessage(
-            initialFilter = { msg ->
-                val user = msg.fromUserMessageOrNull()?.user
-                user is CommonBot && user.id != me.id
-            }
-        ) { message ->
-            val sender = message.fromUserMessageOrNull()?.user
-            println("Message from other bot received (canReadAllGroupMessages=${me.canReadAllGroupMessages}):")
-            println("  sender: ${sender?.firstName} (@${(sender as? CommonBot)?.username?.username})")
-            println("  content: ${message.content}")
-        }
-    }.second.join()
-}

ChecklistsBot/src/main/kotlin/ChecklistsBot.kt

@@ -4,6 +4,7 @@ import dev.inmo.kslog.common.defaultMessageFormatter
 import dev.inmo.kslog.common.setDefaultKSLog
 import dev.inmo.micro_utils.coroutines.runCatchingLogging
 import dev.inmo.micro_utils.coroutines.subscribeLoggingDropExceptions
+import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
 import dev.inmo.tgbotapi.extensions.api.bot.getMe
 import dev.inmo.tgbotapi.extensions.api.bot.getMyStarBalance
 import dev.inmo.tgbotapi.extensions.api.chat.get.getChat
@@ -32,7 +33,7 @@ import dev.inmo.tgbotapi.extensions.utils.previewChannelDirectMessagesChatOrNull
 import dev.inmo.tgbotapi.extensions.utils.suggestedChannelDirectMessagesContentMessageOrNull
 import dev.inmo.tgbotapi.types.checklists.ChecklistTaskId
 import dev.inmo.tgbotapi.types.message.SuggestedPostParameters
-import dev.inmo.tgbotapi.types.message.abstracts.ChatContentMessage
+import dev.inmo.tgbotapi.types.message.abstracts.CommonMessage
 import dev.inmo.tgbotapi.types.message.content.ChecklistContent
 import dev.inmo.tgbotapi.types.message.textsources.TextSourcesList
 import dev.inmo.tgbotapi.types.update.abstracts.Update

CustomBot/src/main/kotlin/CustomBot.kt

@@ -2,7 +2,7 @@ import dev.inmo.kslog.common.KSLog
 import dev.inmo.kslog.common.LogLevel
 import dev.inmo.kslog.common.defaultMessageFormatter
 import dev.inmo.kslog.common.setDefaultKSLog
-import dev.inmo.micro_utils.coroutines.subscribeLoggingDropExceptions
+import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
 import dev.inmo.tgbotapi.extensions.api.bot.getMe
 import dev.inmo.tgbotapi.extensions.api.bot.getMyStarBalance
 import dev.inmo.tgbotapi.extensions.api.chat.get.getChat
@@ -22,7 +22,7 @@ import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onPhoto
 import dev.inmo.tgbotapi.types.media.AudioMediaGroupMemberTelegramMedia
 import dev.inmo.tgbotapi.types.media.toTelegramMediaAudio
 import dev.inmo.tgbotapi.types.media.toTelegramPaidMediaPhoto
-import dev.inmo.tgbotapi.types.message.abstracts.ChatContentMessage
+import dev.inmo.tgbotapi.types.message.abstracts.CommonMessage
 import dev.inmo.tgbotapi.types.update.abstracts.Update
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
@@ -31,8 +31,8 @@ private var BehaviourContextData.update: Update?
     get() = get("update") as? Update
     set(value) = set("update", value)
 
-private var BehaviourContextData.commonMessage: ChatContentMessage<*>?
+private var BehaviourContextData.commonMessage: CommonMessage<*>?
-    get() = get("commonMessage") as? ChatContentMessage<*>
+    get() = get("commonMessage") as? CommonMessage<*>
     set(value) = set("commonMessage", value)
 
 /**
@@ -129,7 +129,7 @@ suspend fun main(vararg args: String) {
             println(it.chatEvent)
         }
 
-        allUpdatesFlow.subscribeLoggingDropExceptions(this) {
+        allUpdatesFlow.subscribeSafelyWithoutExceptions(this) {
             println(it)
         }
     }.second.join()

DeepLinksBot/src/main/kotlin/DeepLinksBot.kt

@@ -1,4 +1,4 @@
-import dev.inmo.micro_utils.coroutines.subscribeLoggingDropExceptions
+import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
 import dev.inmo.tgbotapi.extensions.api.bot.getMe
 import dev.inmo.tgbotapi.extensions.api.send.reply
 import dev.inmo.tgbotapi.extensions.behaviour_builder.expectations.waitDeepLinks
@@ -36,7 +36,7 @@ suspend fun main(vararg args: String) {
         onDeepLink { (it, deepLink) ->
             reply(it, "Ok, I got deep link \"${deepLink}\" in trigger")
         }
-        waitDeepLinks().subscribeLoggingDropExceptions(this) { (it, deepLink) ->
+        waitDeepLinks().subscribeSafelyWithoutExceptions(this) { (it, deepLink) ->
             reply(it, "Ok, I got deep link \"${deepLink}\" in waiter")
             println(triggersHolder.handleableCommandsHolder.handleable)
         }

DraftsBot/src/main/kotlin/DraftsBot.kt

@@ -3,6 +3,7 @@ import dev.inmo.kslog.common.w
 import dev.inmo.micro_utils.coroutines.runCatchingLogging
 import dev.inmo.micro_utils.coroutines.runCatchingSafely
 import dev.inmo.micro_utils.coroutines.subscribeLoggingDropExceptions
+import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
 import dev.inmo.tgbotapi.bot.TelegramBot
 import dev.inmo.tgbotapi.extensions.api.bot.getMe
 import dev.inmo.tgbotapi.extensions.api.bot.setMyCommands
@@ -74,29 +75,8 @@ suspend fun main(vararg args: String) {
             send(it.chat, testText)
         }
 
-        // sendMessageDraft now accepts empty text (length 0 is valid since TG Bot API 9.0)
-        // Useful to show a typing indicator without any text yet
-        onCommand("test_empty_draft") {
-            sendMessageDraftFlowWithTexts(
-                it.chat.id,
-                flow<String> {
-                    emit("") // empty draft — clears / initializes typing indicator with no content
-                    delay(1500L)
-                    val step = 50
-                    var currentLength = step
-                    while (isActive && testText.length > currentLength) {
-                        delay(500L)
-                        emit(testText.take(currentLength))
-                        currentLength += step
-                    }
-                },
-            )
-            send(it.chat, testText)
-        }
-
         setMyCommands(
             BotCommand("test_draft_flow", "Start draft testing with flow"),
-            BotCommand("test_empty_draft", "Draft starting from empty text (TG Bot API 9.0)"),
             scope = BotCommandScope.AllGroupChats
         )
         allUpdatesFlow.subscribeLoggingDropExceptions(this) {

FSMBot/src/main/kotlin/SimpleFSMBot.kt

@@ -1,5 +1,5 @@
 import dev.inmo.micro_utils.coroutines.awaitFirst
-import dev.inmo.micro_utils.coroutines.subscribeLoggingDropExceptions
+import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
 import dev.inmo.micro_utils.fsm.common.State
 import dev.inmo.tgbotapi.extensions.api.send.send
 import dev.inmo.tgbotapi.extensions.behaviour_builder.expectations.waitAnyContentMessage
@@ -13,7 +13,7 @@ import dev.inmo.tgbotapi.extensions.utils.extensions.sameThread
 import dev.inmo.tgbotapi.extensions.utils.textContentOrNull
 import dev.inmo.tgbotapi.extensions.utils.withContentOrNull
 import dev.inmo.tgbotapi.types.IdChatIdentifier
-import dev.inmo.tgbotapi.types.message.abstracts.ChatContentMessage
+import dev.inmo.tgbotapi.types.message.abstracts.CommonMessage
 import dev.inmo.tgbotapi.types.message.content.TextContent
 import dev.inmo.tgbotapi.utils.botCommand
 import dev.inmo.tgbotapi.utils.firstOf
@@ -24,7 +24,7 @@ import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.map
 
 sealed interface BotState : State
-data class ExpectContentOrStopState(override val context: IdChatIdentifier, val sourceMessage: ChatContentMessage<TextContent>) : BotState
+data class ExpectContentOrStopState(override val context: IdChatIdentifier, val sourceMessage: CommonMessage<TextContent>) : BotState
 data class StopState(override val context: IdChatIdentifier) : BotState
 
 suspend fun main(args: Array<String>) {
@@ -97,7 +97,7 @@ suspend fun main(args: Array<String>) {
             startChain(ExpectContentOrStopState(it.chat.id, it.withContentOrNull() ?: return@onContentMessage))
         }
 
-        allUpdatesFlow.subscribeLoggingDropExceptions(this) {
+        allUpdatesFlow.subscribeSafelyWithoutExceptions(this) {
             println(it)
         }
     }.second.join()

FilesLoaderBot/src/main/kotlin/FilesLoaderBot.kt

@@ -1,4 +1,4 @@
-import dev.inmo.micro_utils.coroutines.subscribeLoggingDropExceptions
+import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
 import dev.inmo.tgbotapi.extensions.api.files.downloadFile
 import dev.inmo.tgbotapi.extensions.api.files.downloadFileToTemp
 import dev.inmo.tgbotapi.extensions.api.get.getFileAdditionalInfo
@@ -10,7 +10,6 @@ import dev.inmo.tgbotapi.requests.abstracts.asMultipartFile
 import dev.inmo.tgbotapi.types.actions.*
 import dev.inmo.tgbotapi.types.media.TelegramMediaAudio
 import dev.inmo.tgbotapi.types.media.TelegramMediaDocument
-import dev.inmo.tgbotapi.types.media.TelegramMediaLivePhoto
 import dev.inmo.tgbotapi.types.media.TelegramMediaPhoto
 import dev.inmo.tgbotapi.types.media.TelegramMediaVideo
 import dev.inmo.tgbotapi.types.message.content.*
@@ -47,7 +46,6 @@ suspend fun main(args: Array<String>) {
                 val action = when (content) {
                     is PhotoContent -> UploadPhotoAction
                     is AnimationContent,
-                    is LivePhotoContent,
                     is VideoContent -> UploadVideoAction
                     is StickerContent -> ChooseStickerAction
                     is MediaGroupContent<*> -> UploadPhotoAction
@@ -76,7 +74,7 @@ suspend fun main(args: Array<String>) {
                         )
                         is MediaGroupContent<*> -> replyWithMediaGroup(
                             it,
-                            content.group.mapNotNull {
+                            content.group.map {
                                 when (val innerContent = it.content) {
                                     is AudioContent -> TelegramMediaAudio(
                                         downloadFileToTemp(innerContent.media).asMultipartFile()
@@ -90,10 +88,6 @@ suspend fun main(args: Array<String>) {
                                     is VideoContent -> TelegramMediaVideo(
                                         downloadFileToTemp(innerContent.media).asMultipartFile()
                                     )
-                                    is LivePhotoContent -> TelegramMediaLivePhoto(
-                                        downloadFileToTemp(innerContent.media).asMultipartFile(),
-                                        innerContent.media.photo ?.fileId ?: return@mapNotNull null
-                                    )
                                 }
                             }
                         )
@@ -113,16 +107,10 @@ suspend fun main(args: Array<String>) {
                             it,
                             outFile.asMultipartFile()
                         )
-
-                        is LivePhotoContent -> replyWithLivePhoto(
-                            it,
-                            outFile.asMultipartFile(),
-                            content.media.photo ?.fileId ?: error("Unable to resend live photo files without their photos")
-                        )
                     }
                 }
             }
         }
-        allUpdatesFlow.subscribeLoggingDropExceptions(this) { println(it) }
+        allUpdatesFlow.subscribeSafelyWithoutExceptions(this) { println(it) }
     }.second.join()
 }

GiftsBot/src/main/kotlin/GiftsBot.kt

@@ -2,6 +2,7 @@ import dev.inmo.kslog.common.KSLog
 import dev.inmo.kslog.common.LogLevel
 import dev.inmo.kslog.common.defaultMessageFormatter
 import dev.inmo.kslog.common.setDefaultKSLog
+import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
 import dev.inmo.tgbotapi.extensions.api.bot.getMe
 import dev.inmo.tgbotapi.extensions.api.business.getBusinessAccountGiftsFlow
 import dev.inmo.tgbotapi.extensions.api.gifts.getChatGiftsFlow
@@ -104,7 +105,7 @@ suspend fun main(vararg args: String) {
             }
         }
 
-//        allUpdatesFlow.subscribeLoggingDropExceptions(this) {
+//        allUpdatesFlow.subscribeSafelyWithoutExceptions(this) {
 //            println(it)
 //        }
     }.second.join()

GiveawaysBot/src/main/kotlin/GiveawaysBot.kt

@@ -2,7 +2,7 @@ import dev.inmo.kslog.common.KSLog
 import dev.inmo.kslog.common.LogLevel
 import dev.inmo.kslog.common.defaultMessageFormatter
 import dev.inmo.kslog.common.setDefaultKSLog
-import dev.inmo.micro_utils.coroutines.subscribeLoggingDropExceptions
+import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
 import dev.inmo.tgbotapi.extensions.api.bot.getMe
 import dev.inmo.tgbotapi.extensions.behaviour_builder.telegramBotWithBehaviourAndLongPolling
 import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onGiveawayCompleted
@@ -50,7 +50,7 @@ suspend fun main(vararg args: String) {
             println(it)
         }
 
-//        allUpdatesFlow.subscribeLoggingDropExceptions(this) {
+//        allUpdatesFlow.subscribeSafelyWithoutExceptions(this) {
 //            println(it)
 //        }
     }.second.join()

GuestQueryBot/build.gradle

@@ -1,21 +0,0 @@
-buildscript {
-    repositories {
-        mavenCentral()
-    }
-
-    dependencies {
-        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
-    }
-}
-
-apply plugin: 'kotlin'
-apply plugin: 'application'
-
-mainClassName="GuestQueryBotKt"
-
-
-dependencies {
-    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
-
-    implementation "dev.inmo:tgbotapi:$telegram_bot_api_version"
-}

GuestQueryBot/src/main/kotlin/GuestQueryBot.kt

@@ -1,107 +0,0 @@
-import dev.inmo.kslog.common.KSLog
-import dev.inmo.kslog.common.LogLevel
-import dev.inmo.kslog.common.defaultMessageFormatter
-import dev.inmo.kslog.common.setDefaultKSLog
-import dev.inmo.micro_utils.coroutines.subscribeLoggingDropExceptions
-import dev.inmo.tgbotapi.extensions.api.bot.getMe
-import dev.inmo.tgbotapi.extensions.api.send.reply
-import dev.inmo.tgbotapi.extensions.behaviour_builder.telegramBotWithBehaviourAndLongPolling
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onContentMessage
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onGuestRequestMessage
-import dev.inmo.tgbotapi.extensions.utils.extensions.raw.guest_bot_caller_chat
-import dev.inmo.tgbotapi.extensions.utils.extensions.raw.guest_bot_caller_user
-import dev.inmo.tgbotapi.extensions.utils.publicChatOrNull
-import dev.inmo.tgbotapi.types.InlineQueries.InlineQueryResult.InlineQueryResultArticle
-import dev.inmo.tgbotapi.types.InlineQueries.InputMessageContent.InputTextMessageContent
-import dev.inmo.tgbotapi.types.InlineQueryId
-import dev.inmo.tgbotapi.utils.buildEntities
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-
-/**
- * This bot demonstrates guest mode support introduced in Telegram Bot API.
- *
- * Guest mode allows bots to receive messages and reply within chats they are not a member of.
- * To enable guest queries for your bot, set `supports_guest_queries` in BotFather settings.
- *
- * Key concepts demonstrated:
- * - `supportsGuestQueries` field on the bot itself (via getMe())
- * - `GuestMessageUpdate` — a new update type for messages sent in guest mode
- * - `guestQueryId` — unique ID used to answer the guest query
- * - `guestBotCallerUser` — the user who initiated the guest query
- * - `guestBotCallerChat` — the chat from which the guest query was sent
- * - `answerGuestQuery` / `reply(GuestMessage, InlineQueryResult)` — how to respond
- * - `SentGuestMessage` — the result returned after answering, containing the inline_message_id
- */
-suspend fun main(vararg args: String) {
-    val botToken = args.first()
-    val isDebug = args.any { it == "debug" }
-    val isTestServer = args.any { it == "testServer" }
-
-    if (isDebug) {
-        setDefaultKSLog(
-            KSLog { level: LogLevel, tag: String?, message: Any, throwable: Throwable? ->
-                println(defaultMessageFormatter(level, tag, message, throwable))
-            }
-        )
-    }
-
-    telegramBotWithBehaviourAndLongPolling(
-        botToken,
-        CoroutineScope(Dispatchers.IO),
-        testServer = isTestServer
-    ) {
-        val me = getMe()
-        println("Bot info: $me")
-        // supportsGuestQueries reflects the supports_guest_queries field from the Telegram API
-        println("Supports guest queries: ${me.supportsGuestQueries}")
-
-        onGuestRequestMessage { message ->
-            println("=== Guest message received ===")
-            // guestQueryId is the unique ID required to answer this guest query
-            println("  guestQueryId:       ${message.guestQueryId}")
-            println("  from:               ${message.from}")
-            println("  chat:               ${message.chat}")
-            println("  content:            ${message.content}")
-
-            // reply() on GuestMessage calls answerGuestQuery internally and returns SentGuestMessage
-            val sentGuestMessage = reply(
-                message,
-                InlineQueryResultArticle(
-                    id = InlineQueryId(message.guestQueryId.string),
-                    title = "Guest reply",
-                    inputMessageContent = InputTextMessageContent(
-                        buildEntities {
-                            +"Guest mode reply"
-                            +"\nQuery ID: "
-                            +message.guestQueryId.string
-                        }
-                    ),
-                    description = "Reply to guest query from ${message.from.firstName}"
-                )
-            )
-            // SentGuestMessage contains the inline_message_id of the sent reply
-            println("  SentGuestMessage:   $sentGuestMessage")
-        }
-
-        onContentMessage {
-            println(it)
-            val userCalledGuestMessage = it.guest_bot_caller_user
-            val chatCalledGuestMessage = it.guest_bot_caller_chat ?.publicChatOrNull()
-            if (userCalledGuestMessage != null) {
-                reply(it) {
-                    +"User called guest bot: ${userCalledGuestMessage.lastName + " " + userCalledGuestMessage.firstName}"
-                }
-            }
-            if (chatCalledGuestMessage != null) {
-                reply(it) {
-                    +"Chat called guest bot: ${chatCalledGuestMessage.title}"
-                }
-            }
-        }
-
-        allUpdatesFlow.subscribeLoggingDropExceptions(scope = this) {
-            println(it)
-        }
-    }.second.join()
-}

HelloBot/src/main/kotlin/HelloBot.kt

@@ -1,4 +1,4 @@
-import dev.inmo.micro_utils.coroutines.subscribeLoggingDropExceptions
+import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
 import dev.inmo.tgbotapi.extensions.api.bot.getMe
 import dev.inmo.tgbotapi.extensions.api.chat.get.getChat
 import dev.inmo.tgbotapi.extensions.api.send.reply
@@ -77,6 +77,6 @@ suspend fun main(vararg args: String) {
                 MarkdownV2
             )
         }
-        allUpdatesFlow.subscribeLoggingDropExceptions(this) { println(it) }
+        allUpdatesFlow.subscribeSafelyWithoutExceptions(this) { println(it) }
     }.second.join()
 }

LiveLocationsBot/src/main/kotlin/LiveLocationsBot.kt

@@ -1,4 +1,4 @@
-import dev.inmo.micro_utils.coroutines.subscribeLoggingDropExceptions
+import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
 import dev.inmo.tgbotapi.extensions.api.EditLiveLocationInfo
 import dev.inmo.tgbotapi.extensions.api.edit.location.live.stopLiveLocation
 import dev.inmo.tgbotapi.extensions.api.handleLiveLocation
@@ -61,7 +61,7 @@ suspend fun main(vararg args: String) {
                 stopLiveLocation(it, replyMarkup = null)
             }
         }
-        allUpdatesFlow.subscribeLoggingDropExceptions(this) { println(it) }
+        allUpdatesFlow.subscribeSafelyWithoutExceptions(this) { println(it) }
     }.second.join()
 }
 

LivePhotosBot/build.gradle

@@ -1,21 +0,0 @@
-buildscript {
-    repositories {
-        mavenCentral()
-    }
-
-    dependencies {
-        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
-    }
-}
-
-apply plugin: 'kotlin'
-apply plugin: 'application'
-
-mainClassName="LivePhotosBotKt"
-
-
-dependencies {
-    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
-
-    implementation "dev.inmo:tgbotapi:$telegram_bot_api_version"
-}

LivePhotosBot/src/main/kotlin/LivePhotosBot.kt

@@ -1,166 +0,0 @@
-import dev.inmo.kslog.common.KSLog
-import dev.inmo.kslog.common.LogLevel
-import dev.inmo.kslog.common.defaultMessageFormatter
-import dev.inmo.kslog.common.setDefaultKSLog
-import dev.inmo.micro_utils.coroutines.subscribeLoggingDropExceptions
-import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
-import dev.inmo.tgbotapi.extensions.api.edit.media.editMessageMedia
-import dev.inmo.tgbotapi.extensions.api.send.media.sendLivePhoto
-import dev.inmo.tgbotapi.extensions.api.send.media.sendMediaGroup
-import dev.inmo.tgbotapi.extensions.api.send.media.sendPaidMedia
-import dev.inmo.tgbotapi.extensions.api.send.reply
-import dev.inmo.tgbotapi.extensions.behaviour_builder.telegramBotWithBehaviourAndLongPolling
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onEditedLivePhoto
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onLivePhoto
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onLivePhotoGallery
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onPaidMediaInfoContent
-import dev.inmo.tgbotapi.extensions.utils.withContentOrNull
-import dev.inmo.tgbotapi.types.message.content.LivePhotoContent
-import dev.inmo.tgbotapi.types.message.payments.PaidMedia
-import dev.inmo.tgbotapi.types.media.TelegramMediaLivePhoto
-import dev.inmo.tgbotapi.types.media.TelegramPaidMediaLivePhoto
-import dev.inmo.tgbotapi.types.media.toTelegramPaidMediaLivePhoto
-import dev.inmo.tgbotapi.utils.RiskFeature
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-
-/**
- * This bot demonstrates Live Photos support introduced in Telegram Bot API.
- *
- * Key concepts demonstrated:
- * - [dev.inmo.tgbotapi.types.files.LivePhotoFile] — the LivePhoto class: a photo with an attached short video
- * - [TelegramMediaLivePhoto] — InputMediaLivePhoto: used in sendMediaGroup and editMessageMedia
- * - [LivePhotoContent] — the content type carried in Message.live_photo / ExternalReplyInfo.live_photo
- * - [sendLivePhoto] — method to send a live photo
- * - [PaidMedia.LivePhoto] — PaidMediaLivePhoto: a live photo inside paid media content
- * - [TelegramPaidMediaLivePhoto] — InputPaidMediaLivePhoto: used in sendPaidMedia
- * - sendMediaGroup and editMessageMedia with live photos
- */
-@OptIn(RiskFeature::class)
-suspend fun main(vararg args: String) {
-    val botToken = args.first()
-    val isDebug = args.any { it == "debug" }
-    val isTestServer = args.any { it == "testServer" }
-
-    if (isDebug) {
-        setDefaultKSLog(
-            KSLog { level: LogLevel, tag: String?, message: Any, throwable: Throwable? ->
-                println(defaultMessageFormatter(level, tag, message, throwable))
-            }
-        )
-    }
-
-    telegramBotWithBehaviourAndLongPolling(
-        botToken,
-        CoroutineScope(Dispatchers.IO),
-        testServer = isTestServer
-    ) {
-
-        // Demonstrates: LivePhoto class (LivePhotoFile), live_photo field in Message, sendLivePhoto,
-        //               InputMediaLivePhoto (TelegramMediaLivePhoto), InputPaidMediaLivePhoto (TelegramPaidMediaLivePhoto),
-        //               editMessageMedia with live photo
-        onLivePhoto { message ->
-            // message.content is LivePhotoContent — this is the live_photo field of Message
-            val content: LivePhotoContent = message.content
-
-            // content.media is LivePhotoFile — the LivePhoto class (photo + short video in one file)
-            val livePhotoFile = content.media
-            println("=== Live photo received ===")
-            println("  fileId:        ${livePhotoFile.fileId}")
-            println("  fileUniqueId:  ${livePhotoFile.fileUniqueId}")
-            println("  width:         ${livePhotoFile.width}")
-            println("  height:        ${livePhotoFile.height}")
-            println("  duration:      ${livePhotoFile.duration}s")
-            println("  photo (thumb): ${livePhotoFile.photo?.fileId}")
-            println("  mimeType:      ${livePhotoFile.mimeType}")
-            println("  fileSize:      ${livePhotoFile.fileSize}")
-            println("  caption:       ${content.text}")
-
-            // sendLivePhoto: resend the received live photo back using LivePhotoFile overload
-            val sent = sendLivePhoto(
-                chatId = message.chat.id,
-                livePhoto = livePhotoFile,
-                text = "Resent via sendLivePhoto"
-            )
-            println("  sent message id: ${sent.messageId}")
-
-            // InputPaidMediaLivePhoto (TelegramPaidMediaLivePhoto): send the live photo as paid media (1 star)
-            sendPaidMedia(
-                chatId = message.chat.id,
-                starCount = 1,
-                media = listOf(
-                    // TelegramPaidMediaLivePhoto is InputPaidMediaLivePhoto
-                    TelegramPaidMediaLivePhoto(
-                        file = livePhotoFile.fileId,
-                        photo = livePhotoFile.photo?.fileId ?: livePhotoFile.fileId
-                    )
-                ),
-                text = "Paid live photo (1 star)"
-            )
-
-            // editMessageMedia with InputMediaLivePhoto (TelegramMediaLivePhoto):
-            // edit the previously sent message to replace it with itself via TelegramMediaLivePhoto
-            val sentAsMedia = sent.withContentOrNull<LivePhotoContent>()
-            if (sentAsMedia != null) {
-                editMessageMedia(
-                    message = sentAsMedia,
-                    // TelegramMediaLivePhoto is InputMediaLivePhoto
-                    media = TelegramMediaLivePhoto(
-                        file = livePhotoFile.fileId,
-                        photo = livePhotoFile.photo?.fileId ?: livePhotoFile.fileId,
-                        text = "Edited via editMessageMedia with TelegramMediaLivePhoto"
-                    )
-                )
-            }
-        }
-
-        // Demonstrates: sendMediaGroup with live photos, InputMediaLivePhoto (TelegramMediaLivePhoto)
-        onLivePhotoGallery { mediaGroupContent ->
-            println("=== Live photo gallery received (${mediaGroupContent.group.size} items) ===")
-            mediaGroupContent.group.forEach { groupMember ->
-                val livePhotoFile = groupMember.content.media
-                println("  - fileId: ${livePhotoFile.fileId}, ${livePhotoFile.width}x${livePhotoFile.height}")
-            }
-
-            // sendMediaGroup with TelegramMediaLivePhoto (InputMediaLivePhoto)
-            sendMediaGroup(
-                chatId = mediaGroupContent.group.first().sourceMessage.chat.id,
-                media = mediaGroupContent.group.map { groupMember ->
-                    val livePhotoFile = groupMember.content.media
-                    // TelegramMediaLivePhoto is InputMediaLivePhoto — used here in sendMediaGroup
-                    TelegramMediaLivePhoto(
-                        file = livePhotoFile.fileId,
-                        photo = livePhotoFile.photo?.fileId ?: livePhotoFile.fileId
-                    )
-                }
-            )
-        }
-
-        // Demonstrates: PaidMediaLivePhoto (PaidMedia.LivePhoto) in received paid media content
-        onPaidMediaInfoContent { message ->
-            val paidMedia = message.content.paidMediaInfo.media
-            val livePhotos = paidMedia.filterIsInstance<PaidMedia.LivePhoto>()
-            if (livePhotos.isNotEmpty()) {
-                println("=== Paid media with live photos received ===")
-                livePhotos.forEach { paidLivePhoto ->
-                    // paidLivePhoto is PaidMedia.LivePhoto — PaidMediaLivePhoto class
-                    val livePhotoFile = paidLivePhoto.livePhoto
-                    println("  - fileId: ${livePhotoFile.fileId}, ${livePhotoFile.width}x${livePhotoFile.height}")
-                    println("    duration: ${livePhotoFile.duration}s")
-                }
-                reply(message, "Received ${livePhotos.size} paid live photo(s)")
-            }
-        }
-
-        // Demonstrates: live_photo field in edited messages (EditedMessage with LivePhotoContent)
-        onEditedLivePhoto { message ->
-            println("=== Edited live photo received ===")
-            println("  fileId:  ${message.content.media.fileId}")
-            println("  caption: ${message.content.text}")
-        }
-
-        allUpdatesFlow.subscribeLoggingDropExceptions(scope = this) {
-            println(it)
-        }
-    }.second.join()
-}

ManagedBotsBot/src/main/kotlin/ManagedBotsBot.kt

@@ -5,20 +5,15 @@ import dev.inmo.kslog.common.setDefaultKSLog
 import dev.inmo.micro_utils.coroutines.subscribeLoggingDropExceptions
 import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
 import dev.inmo.tgbotapi.extensions.api.bot.getMe
-import dev.inmo.tgbotapi.extensions.api.getUserPersonalChatMessages
 import dev.inmo.tgbotapi.extensions.api.chat.get.getChat
-import dev.inmo.tgbotapi.extensions.api.managed_bots.getManagedBotAccessSettings
 import dev.inmo.tgbotapi.extensions.api.managed_bots.getManagedBotToken
 import dev.inmo.tgbotapi.extensions.api.managed_bots.replaceManagedBotToken
-import dev.inmo.tgbotapi.extensions.api.managed_bots.setManagedBotAccessSettings
 import dev.inmo.tgbotapi.extensions.api.send.reply
 import dev.inmo.tgbotapi.extensions.api.send.send
-import dev.inmo.tgbotapi.extensions.api.send.sendMessage
 import dev.inmo.tgbotapi.extensions.behaviour_builder.BehaviourContextData
 import dev.inmo.tgbotapi.extensions.behaviour_builder.buildSubcontextInitialAction
 import dev.inmo.tgbotapi.extensions.behaviour_builder.telegramBotWithBehaviourAndLongPolling
 import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onCommand
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onCommandWithArgs
 import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onManagedBotCreated
 import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onManagedBotUpdated
 import dev.inmo.tgbotapi.extensions.utils.chatEventMessageOrNull
@@ -27,12 +22,10 @@ import dev.inmo.tgbotapi.extensions.utils.managedBotCreatedOrNull
 import dev.inmo.tgbotapi.extensions.utils.types.buttons.flatReplyKeyboard
 import dev.inmo.tgbotapi.extensions.utils.types.buttons.replyKeyboard
 import dev.inmo.tgbotapi.extensions.utils.types.buttons.requestManagedBotButton
-import dev.inmo.tgbotapi.types.ChatId
-import dev.inmo.tgbotapi.types.RawChatId
 import dev.inmo.tgbotapi.types.Username
 import dev.inmo.tgbotapi.types.buttons.KeyboardButtonRequestManagedBot
 import dev.inmo.tgbotapi.types.buttons.PreparedKeyboardButtonId
-import dev.inmo.tgbotapi.types.message.abstracts.ChatContentMessage
+import dev.inmo.tgbotapi.types.message.abstracts.CommonMessage
 import dev.inmo.tgbotapi.types.request.RequestId
 import dev.inmo.tgbotapi.types.toChatId
 import dev.inmo.tgbotapi.types.update.abstracts.Update
@@ -43,8 +36,8 @@ private var BehaviourContextData.update: Update?
     get() = get("update") as? Update
     set(value) = set("update", value)
 
-private var BehaviourContextData.commonMessage: ChatContentMessage<*>?
+private var BehaviourContextData.commonMessage: CommonMessage<*>?
-    get() = get("commonMessage") as? ChatContentMessage<*>
+    get() = get("commonMessage") as? CommonMessage<*>
     set(value) = set("commonMessage", value)
 
 /**
@@ -121,16 +114,18 @@ suspend fun main(vararg args: String) {
         }
 
         onManagedBotCreated {
-            val botChatId = it.chatEvent.bot.id.toChatId()
+            reply(it, "Managed bot created successfully: ${it.chatEvent.bot}")
-            reply(it, "Managed bot created successfully: ${it.chatEvent.bot}\nBot ID: ${botChatId.chatId.long}")
+            val token = getManagedBotToken(
-            val token = getManagedBotToken(botChatId)
+                it.chatEvent.bot.id.toChatId()
+            )
             reply(it, "Token: $token")
         }
 
         onManagedBotUpdated {
-            val botChatId = it.bot.id.toChatId()
+            send(it.user, "Managed bot has been updated: ${it.bot}")
-            send(it.user, "Managed bot has been updated: ${it.bot}\nBot ID: ${botChatId.chatId.long}")
+            val token = getManagedBotToken(
-            val token = getManagedBotToken(botChatId)
+                it.bot.id.toChatId()
+            )
             send(it.user, "Token: $token")
         }
 
@@ -141,71 +136,6 @@ suspend fun main(vararg args: String) {
             reply(it, "Token in replace update: ${replaceManagedBotToken(managedBotCreated.bot.id.toChatId())}")
         }
 
-        // getManagedBotAccessSettings — show BotAccessSettings: who can access the given managed bot
-        // Usage: /get_bot_access_settings <botId>
-        onCommandWithArgs("get_bot_access_settings") { message, args ->
-            val botId = args.firstOrNull()?.toLongOrNull()?.let(::RawChatId)?.toChatId()
-                ?: run { reply(message, "Usage: /get_bot_access_settings <botId>\n(Bot ID shown after /keyboard → create bot)"); return@onCommandWithArgs }
-            val settings = runCatching { getManagedBotAccessSettings(botId) }.getOrElse {
-                reply(message, "Error: ${it.message}"); return@onCommandWithArgs
-            }
-            reply(message, buildString {
-                append("Access settings for managed bot $botId:\n")
-                append("  isAccessRestricted: ${settings.isAccessRestricted}\n")
-                if (settings.addedUsers != null) {
-                    append("  allowedUsers: ${settings.addedUsers!!.joinToString { "${it.firstName} (${it.id})" }}")
-                } else {
-                    append("  allowedUsers: all (unrestricted)")
-                }
-            })
-        }
-
-        // setManagedBotAccessSettings — restrict access to a list of user IDs, or open to all
-        // Usage: /set_bot_access_settings <botId> [userId1 userId2 ...]
-        // Omit userIds to open access to all users (addedUserIds = null)
-        onCommandWithArgs("set_bot_access_settings") { message, args ->
-            val botId = args.firstOrNull()?.toLongOrNull()?.let(::RawChatId)?.toChatId()
-                ?: run { reply(message, "Usage: /set_bot_access_settings <botId> [userId1 userId2 ...]"); return@onCommandWithArgs }
-            val allowedIds = args.drop(1).mapNotNull { it.toLongOrNull()?.let(::RawChatId)?.toChatId() }
-            val addedUserIds: List<ChatId>? = allowedIds.ifEmpty { null }
-            runCatching {
-                setManagedBotAccessSettings(botId, addedUserIds)
-            }.onSuccess {
-                reply(message, if (addedUserIds == null) "Access opened to all users." else "Access restricted to ${addedUserIds.size} user(s).")
-            }.onFailure {
-                reply(message, "Error: ${it.message}")
-            }
-        }
-
-        // getUserPersonalChatMessages — get recent messages from the user's personal channel
-        // Works only if the user has a personal channel linked to their account
-        onCommand("get_personal_messages") {
-            val msg = it
-            val userId = msg.chat.id.toChatId()
-            val messages = runCatching { getUserPersonalChatMessages(userId, limit = 10) }.getOrElse { e ->
-                reply(msg, "Error: ${e.message}"); return@onCommand
-            }
-            reply(msg, "Personal channel messages (${messages.size}):\n" +
-                messages.joinToString("\n") { m -> "  [${m.messageId}] ${m.content::class.simpleName}" }
-                    .ifEmpty { "  (none)" }
-            )
-        }
-
-        // Bot-to-bot communication: send a message to another bot by @username
-        // Since TG Bot API 9.0: works if both bots have bot-to-bot communication enabled in BotFather
-        onCommandWithArgs("send_to_bot") { message, args ->
-            val usernameArg = args.firstOrNull() ?: run { reply(message, "Usage: /send_to_bot @username [text]"); return@onCommandWithArgs }
-            val targetUsername = Username.prepare(usernameArg)
-            val text = args.drop(1).joinToString(" ").ifEmpty { "Hello from bot-to-bot communication!" }
-            runCatching {
-                sendMessage(targetUsername, text)
-            }.onSuccess {
-                reply(message, "Message sent to $targetUsername")
-            }.onFailure {
-                reply(message, "Failed to send to $targetUsername: ${it.message}")
-            }
-        }
-
         allUpdatesFlow.subscribeLoggingDropExceptions(this) {
             println(it)
         }

PollsBot/src/main/kotlin/PollsBot.kt

@@ -2,7 +2,7 @@ import dev.inmo.kslog.common.KSLog
 import dev.inmo.kslog.common.LogLevel
 import dev.inmo.kslog.common.defaultMessageFormatter
 import dev.inmo.kslog.common.setDefaultKSLog
-import dev.inmo.micro_utils.coroutines.subscribeLoggingDropExceptions
+import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
 import dev.inmo.tgbotapi.extensions.api.bot.setMyCommands
 import dev.inmo.tgbotapi.extensions.api.send.polls.sendQuizPoll
 import dev.inmo.tgbotapi.extensions.api.send.polls.sendRegularPoll
@@ -16,18 +16,14 @@ import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onPollOp
 import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onPollOptionDeleted
 import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onPollUpdates
 import dev.inmo.tgbotapi.extensions.utils.accessibleMessageOrNull
-import dev.inmo.tgbotapi.extensions.utils.chatContentMessageOrNull
 import dev.inmo.tgbotapi.extensions.utils.customEmojiTextSourceOrNull
 import dev.inmo.tgbotapi.extensions.utils.extensions.parseCommandsWithArgsSources
 import dev.inmo.tgbotapi.types.BotCommand
 import dev.inmo.tgbotapi.types.IdChatIdentifier
 import dev.inmo.tgbotapi.types.PollId
 import dev.inmo.tgbotapi.types.ReplyParameters
-import dev.inmo.tgbotapi.types.media.TelegramMediaLocation
-import dev.inmo.tgbotapi.types.media.TelegramMediaVenue
 import dev.inmo.tgbotapi.types.polls.InputPollOption
 import dev.inmo.tgbotapi.types.polls.PollAnswer
-import dev.inmo.tgbotapi.types.polls.QuizPoll
 import dev.inmo.tgbotapi.utils.buildEntities
 import dev.inmo.tgbotapi.utils.customEmoji
 import dev.inmo.tgbotapi.utils.regular
@@ -39,22 +35,11 @@ import kotlinx.coroutines.sync.withLock
 import kotlin.random.Random
 
 /**
- * This bot demonstrates poll features including the new API additions:
+ * This bot will answer with anonymous or public poll and send message on
+ * any update.
  * 
- * * `/anonymous` — anonymous regular poll
+ * * Use `/anonymous` to take anonymous regular poll
- * * `/public` — public regular poll with option adding
+ * * Use `/public` to take public regular poll
- * * `/quiz` — quiz poll with random correct answer
- * * `/media_poll` — poll with [TelegramMediaLocation] as poll media (InputMediaLocation),
- *   and [TelegramMediaVenue] as option media (InputMediaVenue / InputPollOptionMedia)
- * * `/quiz_media` — quiz poll with [TelegramMediaLocation] as `media` and [TelegramMediaVenue]
- *   as `explanationMedia` (new [QuizPoll.explanationMedia] field)
- * * `/members_only` — poll with `membersOnly = true` (new [dev.inmo.tgbotapi.types.polls.Poll.membersOnly] field)
- * * `/country_codes` — poll with `countryCodes` (new [dev.inmo.tgbotapi.types.polls.Poll.countryCodes] field)
- * * `/single_option` — poll with just 1 option (minimum options count decreased from 2 to 1)
- *
- * [onPollUpdates] prints [dev.inmo.tgbotapi.types.polls.Poll.media], [dev.inmo.tgbotapi.types.polls.Poll.membersOnly],
- * [dev.inmo.tgbotapi.types.polls.Poll.countryCodes], [QuizPoll.explanationMedia], and
- * [dev.inmo.tgbotapi.types.polls.PollOption.media] for each option.
  */
 suspend fun main(vararg args: String) {
     val botToken = args.first()
@@ -188,120 +173,6 @@ suspend fun main(vararg args: String) {
             }
         }
 
-        // TelegramMediaLocation implements InputPollMedia and InputPollOptionMedia (InputMediaLocation)
-        // TelegramMediaVenue implements InputPollMedia and InputPollOptionMedia (InputMediaVenue)
-        // Both can be used as poll question media or as option media
-        onCommand("media_poll") {
-            val sentPoll = sendRegularPoll(
-                it.chat.id,
-                buildEntities { regular("Which venue would you visit?") },
-                listOf(
-                    // InputPollOptionMedia via TelegramMediaVenue (InputMediaVenue)
-                    InputPollOption(
-                        media = TelegramMediaVenue(
-                            latitude = 48.8566,
-                            longitude = 2.3522,
-                            title = "Eiffel Tower",
-                            address = "Champ de Mars, Paris"
-                        )
-                    ) { regular("Eiffel Tower") },
-                    // InputPollOptionMedia via TelegramMediaLocation (InputMediaLocation)
-                    InputPollOption(
-                        media = TelegramMediaLocation(latitude = 51.5007, longitude = -0.1246)
-                    ) { regular("Big Ben") },
-                    InputPollOption { regular("Neither") },
-                ),
-                isAnonymous = false,
-                // InputMediaLocation as InputPollMedia — poll question media
-                media = TelegramMediaLocation(latitude = 48.8566, longitude = 2.3522),
-                replyParameters = ReplyParameters(it)
-            )
-            pollToChatMutex.withLock {
-                pollToChat[sentPoll.content.poll.id] = sentPoll.chat.id
-            }
-        }
-
-        // Demonstrates InputPollMedia on quiz + new QuizPoll.explanationMedia field
-        onCommand("quiz_media") {
-            val sentPoll = sendQuizPoll(
-                it.chat.id,
-                questionEntities = buildEntities { regular("Where is the Eiffel Tower?") },
-                options = listOf(
-                    InputPollOption { regular("Paris") },
-                    InputPollOption { regular("London") },
-                    InputPollOption { regular("Berlin") },
-                ),
-                correctOptionIds = listOf(0),
-                explanation = "The Eiffel Tower is in Paris, France.",
-                isAnonymous = false,
-                // InputMediaLocation as InputPollMedia — poll question media (new Poll.media field)
-                media = TelegramMediaLocation(latitude = 48.8566, longitude = 2.3522),
-                // explanationMedia is new on QuizPoll — media shown with quiz explanation
-                explanationMedia = TelegramMediaVenue(
-                    latitude = 48.8566,
-                    longitude = 2.3522,
-                    title = "Eiffel Tower",
-                    address = "Champ de Mars, 5 Av. Anatole France, Paris"
-                ),
-                replyParameters = ReplyParameters(it)
-            )
-            pollToChatMutex.withLock {
-                pollToChat[sentPoll.content.poll.id] = sentPoll.chat.id
-            }
-        }
-
-        // Demonstrates Poll.membersOnly and the membersOnly sendPoll parameter
-        onCommand("members_only") {
-            val sentPoll = sendRegularPoll(
-                it.chat.id,
-                buildEntities { regular("Members-only poll") },
-                listOf(
-                    InputPollOption { regular("Yes") },
-                    InputPollOption { regular("No") },
-                ),
-                isAnonymous = false,
-                membersOnly = true,
-                replyParameters = ReplyParameters(it)
-            )
-            pollToChatMutex.withLock {
-                pollToChat[sentPoll.content.poll.id] = sentPoll.chat.id
-            }
-        }
-
-        // Demonstrates Poll.countryCodes and the countryCodes sendPoll parameter
-        onCommand("country_codes") {
-            val sentPoll = sendRegularPoll(
-                it.chat.id,
-                buildEntities { regular("Country-targeted poll (US, DE, JP)") },
-                listOf(
-                    InputPollOption { regular("Option A") },
-                    InputPollOption { regular("Option B") },
-                ),
-                isAnonymous = false,
-                countryCodes = listOf("US", "DE", "JP"),
-                replyParameters = ReplyParameters(it)
-            )
-            pollToChatMutex.withLock {
-                pollToChat[sentPoll.content.poll.id] = sentPoll.chat.id
-            }
-        }
-
-        // Demonstrates that minimum poll options count is now 1 (was 2 before)
-        onCommand("single_option") {
-            val sentPoll = sendRegularPoll(
-                it.chat.id,
-                buildEntities { regular("Acknowledge this notice") },
-                listOf(
-                    InputPollOption { regular("Got it") },
-                ),
-                isAnonymous = false,
-                replyParameters = ReplyParameters(it)
-            )
-            pollToChatMutex.withLock {
-                pollToChat[sentPoll.content.poll.id] = sentPoll.chat.id
-            }
-        }
-
         onPollAnswer {
             val chatId = pollToChat[it.pollId] ?: return@onPollAnswer
 
@@ -314,29 +185,14 @@ suspend fun main(vararg args: String) {
         onPollUpdates {
             val chatId = pollToChat[it.id] ?: return@onPollUpdates
 
-            // Poll.media — PollMedia attached to the poll question (new field)
+            when(it.isAnonymous) {
-            // Poll.membersOnly — whether poll is restricted to channel members (new field)
+                false -> send(chatId, "[onPollUpdates] Public poll updated: ${it.options.joinToString()}")
-            // Poll.countryCodes — country restriction list (new field)
+                true -> send(chatId, "[onPollUpdates] Anonymous poll updated: ${it.options.joinToString()}")
-            // QuizPoll.explanationMedia — PollMedia attached to quiz explanation (new field)
-            // PollOption.media — PollMedia attached to each option (new field)
-            val pollInfo = buildString {
-                append("[onPollUpdates] anonymous=${it.isAnonymous}")
-                append(" | media=${it.media}")
-                append(" | membersOnly=${it.membersOnly}")
-                append(" | countryCodes=${it.countryCodes}")
-                if (it is QuizPoll) {
-                    append(" | explanationMedia=${it.explanationMedia}")
             }
-                append("\n  options:")
-                it.options.forEach { option ->
-                    append("\n    ${option.text}: votes=${option.votes}, media=${option.media}")
-                }
-            }
-            send(chatId, pollInfo)
         }
 
         onPollOptionAdded {
-            it.chatEvent.pollMessage ?.accessibleMessageOrNull() ?.chatContentMessageOrNull() ?.let { pollMessage ->
+            it.chatEvent.pollMessage ?.accessibleMessageOrNull() ?.let { pollMessage ->
                 reply(pollMessage) {
                     +"Poll option added: \n"
                     +it.chatEvent.optionTextSources
@@ -344,7 +200,7 @@ suspend fun main(vararg args: String) {
             }
         }
         onPollOptionDeleted {
-            it.chatEvent.pollMessage ?.accessibleMessageOrNull() ?.chatContentMessageOrNull() ?.let { pollMessage ->
+            it.chatEvent.pollMessage ?.accessibleMessageOrNull() ?.let { pollMessage ->
                 reply(pollMessage) {
                     +"Poll option deleted: \n"
                     +it.chatEvent.optionTextSources
@@ -354,7 +210,7 @@ suspend fun main(vararg args: String) {
 
         onContentMessage {
             val replyPollOptionId = it.replyInfo ?.pollOptionId ?: return@onContentMessage
-            it.replyTo ?.accessibleMessageOrNull() ?.chatContentMessageOrNull() ?.let { replied ->
+            it.replyTo ?.accessibleMessageOrNull() ?.let { replied ->
                 reply(replied, pollOptionId = replyPollOptionId) {
                     +"Reply to poll option"
                 }
@@ -365,13 +221,8 @@ suspend fun main(vararg args: String) {
             BotCommand("anonymous", "Create anonymous regular poll"),
             BotCommand("public", "Create non anonymous regular poll"),
             BotCommand("quiz", "Create quiz poll with random right answer"),
-            BotCommand("media_poll", "Poll with location/venue media on question and options"),
-            BotCommand("quiz_media", "Quiz with media and explanationMedia on question/explanation"),
-            BotCommand("members_only", "Poll restricted to channel members only (membersOnly)"),
-            BotCommand("country_codes", "Poll targeted to US, DE, JP users (countryCodes)"),
-            BotCommand("single_option", "Poll with 1 option (minimum is now 1, not 2)"),
         )
 
-        allUpdatesFlow.subscribeLoggingDropExceptions(scope = this) { println(it) }
+        allUpdatesFlow.subscribeSafelyWithoutExceptions(this) { println(it) }
     }.second.join()
 }

RightsChangerBot/build.gradle

@@ -18,5 +18,5 @@ dependencies {
     implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
 
     implementation "dev.inmo:tgbotapi:$telegram_bot_api_version"
-    implementation 'io.ktor:ktor-client-logging-jvm:3.2.3'
+    implementation 'io.ktor:ktor-client-logging-jvm:3.4.2'
 }

RightsChangerBot/src/main/kotlin/RightsChanger.kt

@@ -33,7 +33,6 @@ import dev.inmo.tgbotapi.types.chat.member.AdministratorChatMember
 import dev.inmo.tgbotapi.types.chat.member.ChatCommonAdministratorRights
 import dev.inmo.tgbotapi.types.commands.BotCommandScope
 import dev.inmo.tgbotapi.types.message.abstracts.AccessibleMessage
-import dev.inmo.tgbotapi.types.message.abstracts.ChatMessage
 import dev.inmo.tgbotapi.types.request.RequestId
 import dev.inmo.tgbotapi.utils.*
 import kotlinx.coroutines.flow.filter
@@ -209,7 +208,7 @@ suspend fun main(args: Array<String>) {
         ) {
             val replyMessage = it.replyTo
             val userInReply = replyMessage?.fromUserMessageOrNull()?.user?.id ?: return@onCommand
-            if (replyMessage is ChatMessage) {
+            if (replyMessage is AccessibleMessage) {
                 reply(
                     replyMessage,
                     "Manage keyboard:",
@@ -230,7 +229,7 @@ suspend fun main(args: Array<String>) {
             val replyMessage = it.replyTo
             val userInReply = replyMessage?.fromUserMessageOrNull()?.user?.id ?: return@onCommand
 
-            if (replyMessage is ChatMessage) {
+            if (replyMessage is AccessibleMessage) {
                 reply(
                     replyMessage,
                     "Manage keyboard:",
@@ -248,7 +247,7 @@ suspend fun main(args: Array<String>) {
             initialFilter = { it.user.id == allowedAdmin }
         ) {
             val messageReply =
-                it.message.chatContentMessageOrNull()?.replyTo?.fromUserMessageOrNull() ?: return@onMessageDataCallbackQuery
+                it.message.commonMessageOrNull()?.replyTo?.fromUserMessageOrNull() ?: return@onMessageDataCallbackQuery
             val userId = messageReply.user.id
             val permissions =
                 getUserChatPermissions(it.message.chat.id.toChatId(), userId) ?: return@onMessageDataCallbackQuery
@@ -335,7 +334,7 @@ suspend fun main(args: Array<String>) {
             initialFilter = { it.user.id == allowedAdmin }
         ) {
             val messageReply =
-                it.message.chatContentMessageOrNull()?.replyTo?.fromUserMessageOrNull() ?: return@onMessageDataCallbackQuery
+                it.message.commonMessageOrNull()?.replyTo?.fromUserMessageOrNull() ?: return@onMessageDataCallbackQuery
             val userId = messageReply.user.id
             val permissions =
                 getUserChatPermissions(it.message.chat.id.toChatId(), userId) ?: return@onMessageDataCallbackQuery

SuggestedPosts/src/main/kotlin/SuggestedPostsBot.kt

@@ -31,7 +31,7 @@ import dev.inmo.tgbotapi.extensions.utils.previewChannelDirectMessagesChatOrNull
 import dev.inmo.tgbotapi.extensions.utils.suggestedChannelDirectMessagesContentMessageOrNull
 import dev.inmo.tgbotapi.types.message.SuggestedPostParameters
 import dev.inmo.tgbotapi.types.message.abstracts.ChannelPaidPost
-import dev.inmo.tgbotapi.types.message.abstracts.ChatContentMessage
+import dev.inmo.tgbotapi.types.message.abstracts.CommonMessage
 import dev.inmo.tgbotapi.types.update.abstracts.Update
 import dev.inmo.tgbotapi.utils.firstOf
 import kotlinx.coroutines.CoroutineScope

TagsBot/src/main/kotlin/TagsBot.kt

@@ -3,6 +3,7 @@ import dev.inmo.kslog.common.LogLevel
 import dev.inmo.kslog.common.defaultMessageFormatter
 import dev.inmo.kslog.common.setDefaultKSLog
 import dev.inmo.micro_utils.coroutines.subscribeLoggingDropExceptions
+import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
 import dev.inmo.tgbotapi.abstracts.FromUser
 import dev.inmo.tgbotapi.extensions.api.bot.getMe
 import dev.inmo.tgbotapi.extensions.api.business.getBusinessAccountGiftsFlow

build.gradle

@@ -26,7 +26,7 @@ allprojects {
             }
         }
 
-//        maven { url "https://proxy.nexus.inmo.dev/repository/maven-releases/" }
+        maven { url "https://proxy.nexus.inmo.dev/repository/maven-releases/" }
         mavenLocal()
     }
 }

gradle.properties

@@ -6,8 +6,8 @@ kotlin.daemon.jvmargs=-Xmx3g -Xms500m
 
 
 kotlin_version=2.3.20
-telegram_bot_api_version=34.0.0-t7
+telegram_bot_api_version=33.0.0
 micro_utils_version=0.29.1
 serialization_version=1.10.0
-ktor_version=3.4.1
+ktor_version=3.4.2
 compose_version=1.10.2

settings.gradle

@@ -71,9 +71,3 @@ include ":GiftsBot"
 include ":TagsBot"
 
 include ":ManagedBotsBot"
-
-include ":GuestQueryBot"
-
-include ":LivePhotosBot"
-
-include ":ChatManagementBot"