Merge pull request #10 from ionet-official/fix/telegram-responds-when-not-tagged

fix telegram for responding all messages, even if not tagged

Author: ilkhom19

README.md

@@ -96,8 +96,9 @@ The Discord bot responds to:
 ### Telegram Bot
 
 The Telegram bot responds to:
-- **All Messages**: Send any message directly to the bot
-- **Group Chats**: Add the bot to a group and interact normally
+- **Private Messages**: Send any message directly to the bot in private chat
+- **Mentions**: `@botusername hello there!` in group chats
+- **Replies**: Reply to any bot message in group chats
 
 **Commands:**
 - `/help` - Show help information

app/telegram.py

@@ -89,9 +89,23 @@ async def _handle_message(self, update: Update, context: ContextTypes.DEFAULT_TY
         user = update.effective_user
         chat_id = update.effective_chat.id
         message_text = update.message.text
+        bot_username = context.bot.username
 
         logger.debug(f"Received message from {user.first_name} in chat {chat_id}: {message_text[:100]}...")
 
+        # Check if bot should respond (similar to Discord logic)
+        is_private_chat = update.effective_chat.type == 'private'
+        is_mentioned = f"@{bot_username}" in message_text if bot_username else False
+        is_reply_to_bot = (update.message.reply_to_message and 
+                          update.message.reply_to_message.from_user and
+                          update.message.reply_to_message.from_user.id == context.bot.id)
+
+        logger.debug(f"Message triggers: private={is_private_chat}, mentioned={is_mentioned}, reply_to_bot={is_reply_to_bot}")
+
+        if not (is_private_chat or is_mentioned or is_reply_to_bot):
+            logger.debug("Message doesn't trigger bot, ignoring")
+            return
+
         msg = Message(
             content=message_text,
             author=user.first_name or user.username or "Unknown",
@@ -128,7 +142,7 @@ async def _handle_message(self, update: Update, context: ContextTypes.DEFAULT_TY
                         user_mention = f"@{user.username}" if user.username else user.first_name or "User"
                         response_text = f"{user_mention} {msg.content}"
 
-                    await update.message.reply_text(response_text)
+                    await update.message.reply_text(response_text, parse_mode='Markdown')
                     break
         else:
             logger.error("Message processor not initialized")

tests/test_telegram.py

@@ -124,11 +124,11 @@ async def test_clear_command_without_context(self, telegram_bot):
 
     @pytest.mark.asyncio
     async def test_handle_message_success(self, telegram_bot):
-        """Test successful message handling"""
+        """Test successful message handling with bot mention"""
         # Create mock update
         update = Mock()
         update.message = Mock()
-        update.message.text = "Hello bot!"
+        update.message.text = "Hello @testbot!"  # Include bot mention
         update.effective_user = Mock()
         update.effective_user.first_name = "TestUser"
         update.effective_user.username = "testuser"
@@ -137,10 +137,13 @@ async def test_handle_message_success(self, telegram_bot):
         update.message.date.timestamp.return_value = 1234567890.0
         update.message.message_id = 456
         update.message.reply_text = AsyncMock()
+        update.message.reply_to_message = None  # No reply
 
         # Create mock context
         context = Mock()
         context.bot.send_chat_action = AsyncMock()
+        context.bot.username = "testbot"  # Set bot username for mention detection
+        context.bot.id = 999  # Bot ID
 
         # Mock message processor
         telegram_bot.message_processor.add_message = AsyncMock()
@@ -162,7 +165,7 @@ async def test_handle_message_success(self, telegram_bot):
         assert isinstance(call_args[0][1], Message)
 
         # Verify response was sent with user mention (since it's a group chat)
-        update.message.reply_text.assert_called_once_with("@testuser Hi there!")
+        update.message.reply_text.assert_called_once_with("@testuser Hi there!", parse_mode='Markdown')
 
         # Verify typing action was sent
         context.bot.send_chat_action.assert_called_once_with(chat_id=123, action="typing")
@@ -201,7 +204,7 @@ async def test_handle_message_private_chat(self, telegram_bot):
         await telegram_bot._handle_message(update, context)
 
         # Verify response was sent without user mention (since it's a private chat)
-        update.message.reply_text.assert_called_once_with("Hi there!")
+        update.message.reply_text.assert_called_once_with("Hi there!", parse_mode='Markdown')
 
     @pytest.mark.asyncio
     async def test_handle_message_no_text(self, telegram_bot):
@@ -251,20 +254,24 @@ async def test_handle_message_no_processor(self, telegram_bot):
 
     @pytest.mark.asyncio
     async def test_handle_message_user_name_fallback(self, telegram_bot):
-        """Test message handling with username fallback"""
+        """Test message handling with username fallback in private chat"""
         update = Mock()
         update.message = Mock()
         update.message.text = "Hello"
         update.effective_user = Mock()
         update.effective_user.first_name = None  # No first name
         update.effective_user.username = "testuser"
         update.effective_chat.id = 123
+        update.effective_chat.type = 'private'  # Private chat - no mention needed
         update.message.date.timestamp.return_value = time.time()
         update.message.message_id = 456
         update.message.reply_text = AsyncMock()
+        update.message.reply_to_message = None
 
         context = Mock()
         context.bot.send_chat_action = AsyncMock()
+        context.bot.username = "testbot"
+        context.bot.id = 999
 
         telegram_bot.message_processor.add_message = AsyncMock()
         telegram_bot.message_processor.contexts = {123: Mock()}
@@ -280,20 +287,24 @@ async def test_handle_message_user_name_fallback(self, telegram_bot):
 
     @pytest.mark.asyncio
     async def test_handle_message_unknown_user_fallback(self, telegram_bot):
-        """Test message handling with 'Unknown' fallback"""
+        """Test message handling with 'Unknown' fallback in private chat"""
         update = Mock()
         update.message = Mock()
         update.message.text = "Hello"
         update.effective_user = Mock()
         update.effective_user.first_name = None
         update.effective_user.username = None
         update.effective_chat.id = 123
+        update.effective_chat.type = 'private'  # Private chat - no mention needed
         update.message.date.timestamp.return_value = time.time()
         update.message.message_id = 456
         update.message.reply_text = AsyncMock()
+        update.message.reply_to_message = None
 
         context = Mock()
         context.bot.send_chat_action = AsyncMock()
+        context.bot.username = "testbot"
+        context.bot.id = 999
 
         telegram_bot.message_processor.add_message = AsyncMock()
         telegram_bot.message_processor.contexts = {123: Mock()}
@@ -307,6 +318,36 @@ async def test_handle_message_unknown_user_fallback(self, telegram_bot):
         message = call_args[0][1]
         assert message.author == "Unknown"
 
+    @pytest.mark.asyncio
+    async def test_handle_message_ignores_non_triggered_messages(self, telegram_bot):
+        """Test that bot ignores messages in groups without mention/reply"""
+        update = Mock()
+        update.message = Mock()
+        update.message.text = "Hello everyone!"  # No bot mention
+        update.effective_user = Mock()
+        update.effective_user.first_name = "TestUser"
+        update.effective_user.username = "testuser"
+        update.effective_chat.id = 123
+        update.effective_chat.type = 'group'  # Group chat
+        update.message.date.timestamp.return_value = time.time()
+        update.message.message_id = 456
+        update.message.reply_text = AsyncMock()
+        update.message.reply_to_message = None  # No reply
+        
+        context = Mock()
+        context.bot.send_chat_action = AsyncMock()
+        context.bot.username = "testbot"
+        context.bot.id = 999
+        
+        telegram_bot.message_processor.add_message = AsyncMock()
+        
+        await telegram_bot._handle_message(update, context)
+        
+        # Verify message was NOT added to processor (bot should ignore it)
+        telegram_bot.message_processor.add_message.assert_not_called()
+        update.message.reply_text.assert_not_called()
+        context.bot.send_chat_action.assert_not_called()
+
     @pytest.mark.asyncio
     async def test_handle_message_waits_for_processing(self, telegram_bot):
         """Test that message handling waits for processing to complete"""