Build and run agents you can see, understand and trust.
Python agentchatbotlarge-language-modelsllmllm-agentmcpmulti-agentmulti-modalreact-agentrealtime-agentvoice-agentvoice-assistant
fix(message-bus): refresh in-memory queue ttl on push (#3420)
haotianqi666f125755cfa30
diff --git a/src/agentscope/app/message_bus/_base.py b/src/agentscope/app/message_bus/_base.pyindex f0989b4d9..52a2d4663 100644--- a/src/agentscope/app/message_bus/_base.py+++ b/src/agentscope/app/message_bus/_base.py@@ -118,9 +118,8 @@ class MessageBus(ABC): # pylint: disable=too-many-public-methodscaller's responsibility.ttl_secs (`int | None`, optional):If set, refresh the queue key's expiry to this many- seconds on every push (sliding TTL). When ``None``, the- key never expires and must be drained or deleted- explicitly.+ seconds on every push (sliding TTL). ``None`` leaves an+ existing expiry unchanged; a new key has no expiry.Returns:`str`:diff --git a/src/agentscope/app/message_bus/_in_memory_message_bus.py b/src/agentscope/app/message_bus/_in_memory_message_bus.pyindex bf5c370b5..dbbde1622 100644--- a/src/agentscope/app/message_bus/_in_memory_message_bus.py+++ b/src/agentscope/app/message_bus/_in_memory_message_bus.py@@ -36,7 +36,7 @@ class InMemoryMessageBus(Mapping of bus modes to in-memory structures:- **Mode A (drain queue)** — each key maps to- ``(entry_id, payload, expire_at)`` tuples. ``queue_push`` appends;+ ``(entry_id, payload)`` tuples. ``queue_push`` appends;``queue_drain`` pops from the front (FIFO) and deletes the returnedentries.- **Mode C (replay log)** — same underlying list structure, but@@ -61,12 +61,10 @@ class InMemoryMessageBus(# Global auto-increment counter for entry ids.self._seq: int = 0- # Mode A — drain queues: key -> [(entry_id, payload), ...]- # (entry_id, payload, expire_at | None) — expire_at is monotonic.- self._queues: dict[- str,- list[tuple[str, dict, float | None]],- ] = defaultdict(list)+ # Mode A — drain queues. Expiry belongs to the whole key, as in+ # Redis Streams, and is checked lazily on push, read, or drain.+ self._queues: dict[str, list[tuple[str, dict]]] = defaultdict(list)+ self._queue_expires_at: dict[str, float] = {}# Mode C — replay logs: key -> [(entry_id, payload), ...]self._logs: dict[str, list[tuple[str, dict]]] = defaultdict(list)@@ -128,6 +126,20 @@ class InMemoryMessageBus(# Mode A — drain queue# ------------------------------------------------------------------+ def _drop_expired_queue(self, key: str, now: float) -> None:+ """Remove ``key`` if its queue lifetime has elapsed.++ Args:+ key (`str`):+ Queue identifier.+ now (`float`):+ Current monotonic time.+ """+ expires_at = self._queue_expires_at.get(key)+ if expires_at is not None and expires_at <= now:+ self._queues.pop(key, None)+ self._queue_expires_at.pop(key, None)+async def queue_push(self,key: str,@@ -137,9 +149,8 @@ class InMemoryMessageBus() -> str:"""Append ``payload`` to the in-memory drain queue at ``key``.- When ``ttl_secs`` is set the entry expires after that many- seconds; expired entries are dropped here and on drain, so a- never-drained key stays bounded.+ When ``ttl_secs`` is set, refresh the whole queue's expiry.+ Expired queues are removed on the next push, read, or drain.Args:key (`str`):@@ -147,18 +158,22 @@ class InMemoryMessageBus(payload (`dict`):JSON-serializable dict to enqueue.ttl_secs (`int | None`, optional):- Entry lifetime in seconds; ``None`` never expires.+ Queue lifetime in seconds. ``None`` leaves the current+ expiry unchanged, if one exists.Returns:`str`:The synthetic entry id assigned to this entry."""entry_id = self._next_id()- queue = self._queues[key]now = time.monotonic()- queue[:] = [e for e in queue if e[2] is None or e[2] > now]- expire_at = now + ttl_secs if ttl_secs is not None else None- queue.append((entry_id, deepcopy(payload), expire_at))+ self._drop_expired_queue(key, now)+ if ttl_secs is not None and ttl_secs <= 0:+ await self.queue_delete(key)+ return entry_id+ self._queues[key].append((entry_id, deepcopy(payload)))+ if ttl_secs is not None:+ self._queue_expires_at[key] = now + ttl_secsreturn entry_idasync def queue_drain(@@ -180,16 +195,13 @@ class InMemoryMessageBus(`list[tuple[str, dict]]`:``(entry_id, payload)`` pairs in arrival order."""+ self._drop_expired_queue(key, time.monotonic())q = self._queues.get(key)if not q:return []- now = time.monotonic()- alive = [e for e in q if e[2] is None or e[2] > now]- drained = alive[:max_count]- self._queues[key] = alive[max_count:]- return deepcopy(- [(entry_id, payload) for entry_id, payload, _ in drained],- )+ drained = q[:max_count]+ self._queues[key] = q[max_count:]+ return deepcopy(drained)async def queue_read(self,@@ -208,17 +220,8 @@ class InMemoryMessageBus(`list[tuple[str, dict]]`:Deep-copied ``(entry_id, payload)`` pairs."""- q = self._queues.get(key, [])- now = time.monotonic()- alive = [entry for entry in q if entry[2] is None or entry[2] > now]- if q:- self._queues[key] = alive- return deepcopy(- [- (entry_id, payload)- for entry_id, payload, _expire_at in alive[:max_count]- ],- )+ self._drop_expired_queue(key, time.monotonic())+ return deepcopy(self._queues.get(key, [])[:max_count])async def queue_replace(self,@@ -238,13 +241,14 @@ class InMemoryMessageBus(Fresh transport-level ids assigned to the new entries."""entries = [- (self._next_id(), deepcopy(payload), None) for payload in payloads+ (self._next_id(), deepcopy(payload)) for payload in payloads]if entries:self._queues[key] = entrieselse:self._queues.pop(key, None)- return [entry_id for entry_id, _payload, _expire_at in entries]+ self._queue_expires_at.pop(key, None)+ return [entry_id for entry_id, _payload in entries]async def queue_delete(self, key: str) -> None:"""Delete the drain queue at ``key``.@@ -254,6 +258,7 @@ class InMemoryMessageBus(Queue identifier."""self._queues.pop(key, None)+ self._queue_expires_at.pop(key, None)# ------------------------------------------------------------------# Mode C — replay logdiff --git a/src/agentscope/app/message_bus/_redis_message_bus.py b/src/agentscope/app/message_bus/_redis_message_bus.pyindex afed73d69..f01090834 100644--- a/src/agentscope/app/message_bus/_redis_message_bus.py+++ b/src/agentscope/app/message_bus/_redis_message_bus.py@@ -270,8 +270,8 @@ class RedisMessageBus(MessageBus): # pylint: disable=too-many-public-methodsfield of a Redis Stream entry.ttl_secs (`int | None`, optional):If set, refresh the key's expiry on every push- (sliding TTL). ``None`` means no TTL — the queue- persists until drained or deleted explicitly.+ (sliding TTL). ``None`` leaves an existing expiry+ unchanged; a new key has no expiry.Returns:`str`:diff --git a/tests/channel_gateway_test.py b/tests/channel_gateway_test.pyindex 8b7539e27..5a006de00 100644--- a/tests/channel_gateway_test.py+++ b/tests/channel_gateway_test.py@@ -12,6 +12,7 @@ import asynciofrom types import SimpleNamespacefrom typing import Any, AsyncIteratorfrom unittest import IsolatedAsyncioTestCase+from unittest.mock import patchfrom utils import AnyString@@ -31,6 +32,7 @@ from agentscope.message import Msg, ToolCallBlock, ToolCallStatefrom agentscope.state import AgentStatefrom agentscope.app.message_bus import InMemoryMessageBusfrom agentscope.app.message_bus import MessageBusKeys+from agentscope.app.message_bus import _in_memory_message_bus as _busfrom agentscope.app.storage import (ChannelBinding,ChannelRecord,@@ -312,6 +314,34 @@ class MediaBufferTest(IsolatedAsyncioTestCase):self.assertIsInstance(content[0], DataBlock)self.assertIsInstance(content[-1], TextBlock)+ async def test_new_media_refreshes_buffer_for_earlier_media(self) -> None:+ """All buffered images survive until the last push's deadline."""+ bus = InMemoryMessageBus()+ gw = ChannelGateway(+ storage=None,+ message_bus=bus,+ workspace_manager=_WM(isolation=IsolationPolicy.PER_AGENT),+ )+ first = self._media_event("a.png")+ second = self._media_event("b.png")+ text = ChannelEvent(+ channel_id="c",+ channel_user_id="u",+ chat_id="chat",+ content=[TextBlock(text="look")],+ )+ with patch.object(_bus.time, "monotonic", return_value=0):+ await gw._aggregate_media(first)+ with patch.object(_bus.time, "monotonic", return_value=240):+ await gw._aggregate_media(second)+ with patch.object(_bus.time, "monotonic", return_value=360):+ content = await gw._aggregate_media(text)++ self.assertEqual(+ content,+ [*first.content, *second.content, *text.content],+ )+class _RecordingStorage:"""Storage stub capturing what a session was upserted with."""diff --git a/tests/in_memory_message_bus_test.py b/tests/in_memory_message_bus_test.pyindex 5bbccbdba..0bb6c6037 100644--- a/tests/in_memory_message_bus_test.py+++ b/tests/in_memory_message_bus_test.py@@ -106,6 +106,47 @@ class TestQueuePrimitive(IsolatedAsyncioTestCase):[{"i": 3}, {"i": 2}],)+ async def test_queue_read_observes_sliding_expiry(self) -> None:+ """Reads retain all entries until the refreshed key deadline."""+ with patch.object(_bus.time, "monotonic", return_value=0):+ first_id = await self.bus.queue_push("k", {"i": 1}, ttl_secs=10)+ with patch.object(_bus.time, "monotonic", return_value=5):+ second_id = await self.bus.queue_push("k", {"i": 2}, ttl_secs=10)+ with patch.object(_bus.time, "monotonic", return_value=11):+ self.assertEqual(+ await self.bus.queue_read("k", max_count=1),+ [(first_id, {"i": 1})],+ )+ self.assertEqual(+ await self.bus.queue_read("k"),+ [(first_id, {"i": 1}), (second_id, {"i": 2})],+ )+ with patch.object(_bus.time, "monotonic", return_value=15):+ self.assertEqual(await self.bus.queue_read("k"), [])+ self.assertEqual(await self.bus.queue_drain("k"), [])++ async def test_queue_replace_clears_existing_expiry(self) -> None:+ """Replacement queues do not inherit the old key's deadline."""+ cases: tuple[list[dict], ...] = ([{"nested": {"i": 2}}], [])+ for payloads in cases:+ with self.subTest(payloads=payloads):+ with patch.object(_bus.time, "monotonic", return_value=0):+ await self.bus.queue_push("k", {"i": 1}, ttl_secs=10)+ with patch.object(_bus.time, "monotonic", return_value=5):+ ids = await self.bus.queue_replace("k", payloads)+ expected: list[tuple[str, dict]] = [+ (entry_id, {"nested": {"i": 2}}) for entry_id in ids+ ]+ self.assertEqual(len(ids), len(payloads))+ if payloads:+ payloads[0]["nested"]["i"] = 3+ else:+ entry_id = await self.bus.queue_push("k", {"i": 3})+ expected = [(entry_id, {"i": 3})]+ with patch.object(_bus.time, "monotonic", return_value=11):+ self.assertEqual(await self.bus.queue_read("k"), expected)+ self.assertEqual(await self.bus.queue_drain("k"), expected)+async def test_queue_isolation_between_keys(self) -> None:"""Pushes to different keys are independent."""await self.bus.queue_push("a", {"x": 1})@@ -121,6 +162,40 @@ class TestQueuePrimitive(IsolatedAsyncioTestCase):self.assertEqual(await self.bus.queue_drain("k"), [])+ async def test_push_refreshes_ttl_for_whole_queue(self) -> None:+ """A later push keeps earlier entries until the refreshed deadline."""+ with patch.object(_bus.time, "monotonic", return_value=0):+ await self.bus.queue_push("k", {"i": 1}, ttl_secs=10)+ with patch.object(_bus.time, "monotonic", return_value=5):+ await self.bus.queue_push("k", {"i": 2}, ttl_secs=10)+ with patch.object(_bus.time, "monotonic", return_value=11):+ entries = await self.bus.queue_drain("k")++ self.assertEqual(+ [payload for _, payload in entries],+ [{"i": 1}, {"i": 2}],+ )++ async def test_zero_ttl_expires_existing_queue(self) -> None:+ """An immediate key expiry also removes entries already queued."""+ await self.bus.queue_push("k", {"i": 1})+ await self.bus.queue_push("k", {"i": 2}, ttl_secs=0)++ self.assertEqual(await self.bus.queue_drain("k"), [])++ async def test_push_without_ttl_keeps_existing_key_expiry(self) -> None:+ """Omitting TTL does not cancel a previously set key expiry."""+ with patch.object(_bus.time, "monotonic", return_value=0):+ await self.bus.queue_push("k", {"i": 1}, ttl_secs=10)+ with patch.object(_bus.time, "monotonic", return_value=5):+ first = await self.bus.queue_drain("k")+ await self.bus.queue_push("k", {"i": 2})+ with patch.object(_bus.time, "monotonic", return_value=11):+ remaining = await self.bus.queue_drain("k")++ self.assertEqual([payload for _, payload in first], [{"i": 1}])+ self.assertEqual(remaining, [])+class TestLogPrimitive(IsolatedAsyncioTestCase):"""Mode C — replay log: append / read with cursor / trim."""