fix: keep agent typing status while queued

tests/test_telegram_typing_lifecycle.py

@@ -1,7 +1,10 @@
+import asyncio
 import time
 import unittest
-from unittest.mock import Mock, patch
+from types import SimpleNamespace
+from unittest.mock import AsyncMock, Mock, patch
 
+from app.agent import AgentManager, _MessageTask
 from app.chain.message import MessageChain
 from app.modules.telegram.telegram import Telegram
 from app.schemas.types import MessageChannel
@@ -63,6 +66,22 @@ class TestTelegramTypingLifecycle(unittest.TestCase):
 
         self.assertNotIn("chat-3", Telegram._typing_tasks)
 
+    def test_agent_managed_send_msg_keeps_typing_for_worker_cleanup(self):
+        telegram = self._telegram_client()
+        sent = SimpleNamespace(message_id=1, chat=SimpleNamespace(id="chat-1"))
+
+        with patch.object(
+                telegram, "_Telegram__send_request", return_value=sent
+        ), patch.object(telegram, "_stop_typing_task") as stop_typing:
+            result = telegram.send_msg(
+                title="处理中",
+                userid="10001",
+                stop_typing=False,
+            )
+
+        self.assertTrue(result["success"])
+        stop_typing.assert_not_called()
+
     def test_slash_command_stops_typing_when_message_handler_returns(self):
         chain = MessageChain.__new__(MessageChain)
         status = MessageChain._ProcessingStatus(
@@ -184,6 +203,112 @@ class TestTelegramTypingLifecycle(unittest.TestCase):
             status=status.to_dict(),
         )
 
+    def test_agent_manager_defers_shared_typing_until_queued_task_finishes(self):
+        async def _run():
+            manager = AgentManager()
+            queue = asyncio.Queue()
+            first = _MessageTask(
+                session_id="session-1",
+                user_id="10001",
+                message="第一条",
+                processing_status={
+                    "channel": MessageChannel.Telegram.value,
+                    "source": "telegram-test",
+                    "userid": "10001",
+                    "chat_id": "-100",
+                    "metadata": {"kind": "typing"},
+                },
+            )
+            second = _MessageTask(
+                session_id="session-1",
+                user_id="10001",
+                message="第二条",
+                processing_status={
+                    "channel": MessageChannel.Telegram.value,
+                    "source": "telegram-test",
+                    "userid": "10001",
+                    "chat_id": "-100",
+                    "metadata": {"kind": "typing"},
+                },
+            )
+            await queue.put(second)
+
+            with patch(
+                    "app.agent._async_finish_processing_status",
+                    new_callable=AsyncMock,
+            ) as finish_status:
+                await manager._finish_task_processing_status(
+                    session_id="session-1",
+                    task=first,
+                    queue=queue,
+                )
+                finish_status.assert_not_awaited()
+                self.assertEqual(
+                    manager._deferred_processing_statuses["session-1"],
+                    first.processing_status,
+                )
+
+                queue.get_nowait()
+                await manager._finish_task_processing_status(
+                    session_id="session-1",
+                    task=second,
+                    queue=queue,
+                )
+
+            finish_status.assert_awaited_once_with(
+                second.processing_status, "10001"
+            )
+            self.assertNotIn("session-1", manager._deferred_processing_statuses)
+
+        asyncio.run(_run())
+
+    def test_agent_manager_closes_deferred_typing_when_next_task_has_no_status(self):
+        async def _run():
+            manager = AgentManager()
+            queue = asyncio.Queue()
+            first = _MessageTask(
+                session_id="session-1",
+                user_id="10001",
+                message="第一条",
+                processing_status={
+                    "channel": MessageChannel.Telegram.value,
+                    "source": "telegram-test",
+                    "userid": "10001",
+                    "chat_id": "-100",
+                    "metadata": {"kind": "typing"},
+                },
+            )
+            second = _MessageTask(
+                session_id="session-1",
+                user_id="10001",
+                message="第二条",
+                processing_status=None,
+            )
+            await queue.put(second)
+
+            with patch(
+                    "app.agent._async_finish_processing_status",
+                    new_callable=AsyncMock,
+            ) as finish_status:
+                await manager._finish_task_processing_status(
+                    session_id="session-1",
+                    task=first,
+                    queue=queue,
+                )
+                queue.get_nowait()
+                await manager._finish_task_processing_status(
+                    session_id="session-1",
+                    task=second,
+                    queue=queue,
+                )
+
+            finish_status.assert_awaited_once_with(
+                first.processing_status, "10001"
+            )
+            self.assertNotIn("session-1", manager._deferred_processing_statuses)
+
+        asyncio.run(_run())
+
 
 if __name__ == "__main__":
     unittest.main()