Skip to content

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

fix(middleware): prevent KeyError in budget middleware when ReplyEndEvent is swallowed (#2419)

Terminator66666689a830695c6c
diff --git a/src/agentscope/middleware/_budget.py b/src/agentscope/middleware/_budget.py
index 0c1347544..b97429a7b 100644
--- a/src/agentscope/middleware/_budget.py
+++ b/src/agentscope/middleware/_budget.py
@@ -2,7 +2,7 @@
"""Budget control middleware for AgentScope agents."""
from typing import AsyncGenerator, Callable, TYPE_CHECKING
-from ..event import ModelCallEndEvent, ReplyStartEvent, ReplyEndEvent
+from ..event import ModelCallEndEvent, ReplyStartEvent
from ..message import AssistantMsg, HintBlock
from ..tool import ToolChoice
from ._base import MiddlewareBase
@@ -35,8 +35,8 @@ class ReplyBudgetControlMiddleware(MiddlewareBase):
Budget state is stored in
:attr:`~agentscope.agent.AgentState.middle_context`
keyed by the middleware key, so it persists across human-in-the-loop (HITL)
- interruptions and resumptions. State is automatically cleaned up when the
- reply ends via a :class:`~agentscope.event.ReplyEndEvent`.
+ interruptions and resumptions. State is reset when the next reply starts
+ via a :class:`~agentscope.event.ReplyStartEvent`.
.. note::
The middleware is stateless on the instance itself — all runtime state
@@ -103,10 +103,9 @@ class ReplyBudgetControlMiddleware(MiddlewareBase):
) -> AsyncGenerator:
"""Manage per-reply budget state in ``agent.state.middle_context``.
- Initializes the weighted cost counter for the reply on
- :class:`~agentscope.event.ReplyStartEvent`, accumulates cost on each
- :class:`~agentscope.event.ModelCallEndEvent`, and removes the entry on
- :class:`~agentscope.event.ReplyEndEvent`.
+ Resets the weighted cost counter to the new reply on
+ :class:`~agentscope.event.ReplyStartEvent` and accumulates cost on
+ each :class:`~agentscope.event.ModelCallEndEvent`.
Args:
agent (`Agent`):
@@ -124,22 +123,15 @@ class ReplyBudgetControlMiddleware(MiddlewareBase):
async for event in next_handler(**input_kwargs):
if isinstance(event, ReplyStartEvent):
- # Initialize the token counting number
- if middleware_key not in agent.state.middle_context:
- agent.state.middle_context[middleware_key] = {}
- agent.state.middle_context[middleware_key][event.reply_id] = 0
-
- elif isinstance(event, ReplyEndEvent):
- # Clean up the token counting number
- agent.state.middle_context[middleware_key].pop(
- event.reply_id,
- None,
- )
+ # Start counting for this reply, dropping the previous one.
+ # Not cleaned on ReplyEndEvent: an outer middleware may
+ # swallow it and the same reply then keeps spending tokens
+ agent.state.middle_context[middleware_key] = {
+ event.reply_id: 0,
+ }
elif isinstance(event, ModelCallEndEvent):
# Update the used tokens
- if middleware_key not in agent.state.middle_context:
- agent.state.middle_context[middleware_key] = {}
agent.state.middle_context[middleware_key][event.reply_id] += (
self.input_token_weight * event.input_tokens
+ self.output_token_weight * event.output_tokens
diff --git a/tests/middleware_budget_test.py b/tests/middleware_budget_test.py
index c6a8c5438..4dc0cc193 100644
--- a/tests/middleware_budget_test.py
+++ b/tests/middleware_budget_test.py
@@ -1,19 +1,23 @@
# -*- coding: utf-8 -*-
"""Unit tests for BudgetControlMiddleware."""
-from typing import Any
+from typing import Any, AsyncGenerator, Callable
from unittest.async_case import IsolatedAsyncioTestCase
from utils import MockModel
from agentscope.agent import Agent
from agentscope.message import UserMsg, TextBlock, ToolCallBlock, HintBlock
-from agentscope.middleware import ReplyBudgetControlMiddleware
+from agentscope.middleware import MiddlewareBase, ReplyBudgetControlMiddleware
from agentscope.model import ChatResponse, ChatUsage
from agentscope.permission import (
PermissionBehavior,
PermissionContext,
PermissionDecision,
)
-from agentscope.event import UserConfirmResultEvent, ConfirmResult
+from agentscope.event import (
+ ConfirmResult,
+ ReplyEndEvent,
+ UserConfirmResultEvent,
+)
from agentscope.tool import ToolBase, Toolkit, ToolChunk
@@ -336,11 +340,14 @@ class TestBudgetControlMiddleware(IsolatedAsyncioTestCase):
]
self.assertGreater(len(hint_msgs), 0)
- async def test_state_cleanup_after_reply(self) -> None:
- """middle_context entry for the reply is removed after reply ends."""
+ async def test_state_reset_on_next_reply(self) -> None:
+ """middle_context only keeps the counter of the latest reply."""
model = MockModel()
model.set_responses(
- [_response("done", input_tokens=10, output_tokens=5)],
+ [
+ _response("done", input_tokens=10, output_tokens=5),
+ _response("done again", input_tokens=20, output_tokens=8),
+ ],
)
middleware = ReplyBudgetControlMiddleware(token_budget=1000)
@@ -353,11 +360,63 @@ class TestBudgetControlMiddleware(IsolatedAsyncioTestCase):
)
await agent.reply(UserMsg("user", "hello"))
+ await agent.reply(UserMsg("user", "hello again"))
middleware_key = await middleware.get_middleware_key()
- bucket = agent.state.middle_context.get(middleware_key, {})
- # All per-reply entries must have been cleaned up
- self.assertEqual(len(bucket), 0)
+ self.assertDictEqual(
+ agent.state.middle_context[middleware_key],
+ {agent.state.reply_id: 28},
+ )
+
+ async def test_swallowed_reply_end_keeps_counting(self) -> None:
+ """A redo round forced by swallowing the ReplyEndEvent spends the
+ budget of the same reply."""
+
+ class SwallowOnceMiddleware(MiddlewareBase):
+ """Swallow the first ReplyEndEvent to force a redo round."""
+
+ def __init__(self) -> None:
+ """Initialize the swallow flag."""
+ self.swallowed = False
+
+ async def on_reply(
+ self,
+ agent: Agent,
+ input_kwargs: dict,
+ next_handler: Callable[..., AsyncGenerator],
+ ) -> AsyncGenerator:
+ """Swallow the first ReplyEndEvent, pass everything else."""
+ async for item in next_handler(**input_kwargs):
+ if isinstance(item, ReplyEndEvent) and not self.swallowed:
+ self.swallowed = True
+ continue
+ yield item
+
+ model = MockModel()
+ model.set_responses(
+ [
+ _response("first answer", input_tokens=10, output_tokens=5),
+ _response("second answer", input_tokens=20, output_tokens=8),
+ ],
+ )
+
+ middleware = ReplyBudgetControlMiddleware(token_budget=1000)
+ agent = Agent(
+ name="test_agent",
+ system_prompt="you are helpful",
+ model=model,
+ toolkit=self.toolkit,
+ middlewares=[SwallowOnceMiddleware(), middleware],
+ )
+
+ msg = await agent.reply(UserMsg("user", "hello"))
+
+ self.assertEqual(msg.get_text_content(), "second answer")
+ middleware_key = await middleware.get_middleware_key()
+ self.assertDictEqual(
+ agent.state.middle_context[middleware_key],
+ {agent.state.reply_id: 43},
+ )
async def test_token_accumulation_persists_across_hitl(self) -> None:
"""Token accumulation in middle_context persists across HITL boundary.
@@ -471,6 +530,8 @@ class TestBudgetControlMiddleware(IsolatedAsyncioTestCase):
]
self.assertGreater(len(hint_msgs), 0)
- # middle_context must be cleaned up after reply ends
- bucket = agent.state.middle_context.get(middleware_key, {})
- self.assertNotIn(reply_id, bucket)
+ # Both model calls are counted on the same reply
+ self.assertDictEqual(
+ agent.state.middle_context[middleware_key],
+ {reply_id: 370},
+ )