Skip to content

Build and run agents you can see, understand and trust.

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.py
index 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-methods
caller'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.py
index 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 returned
entries.
- **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_secs
return entry_id
async 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] = entries
else:
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 log
diff --git a/src/agentscope/app/message_bus/_redis_message_bus.py b/src/agentscope/app/message_bus/_redis_message_bus.py
index 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-methods
field 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.py
index 8b7539e27..5a006de00 100644
--- a/tests/channel_gateway_test.py
+++ b/tests/channel_gateway_test.py
@@ -12,6 +12,7 @@ import asyncio
from types import SimpleNamespace
from typing import Any, AsyncIterator
from unittest import IsolatedAsyncioTestCase
+from unittest.mock import patch
from utils import AnyString
@@ -31,6 +32,7 @@ from agentscope.message import Msg, ToolCallBlock, ToolCallState
from agentscope.state import AgentState
from agentscope.app.message_bus import InMemoryMessageBus
from agentscope.app.message_bus import MessageBusKeys
+from agentscope.app.message_bus import _in_memory_message_bus as _bus
from 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.py
index 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."""