Files
bot042/tests/test_stream.py
T
openbot 5da55f8d17 fix(flows): 步数预算与图硬上限分离,预算耗尽时优雅收尾
max_steps 以前同时充当软预算和 recursion_limit,于是预算耗尽的那一刻
必然触发 GraphRecursionError:模型连一句收尾都来不及说,用户只收到
「处理消息时出错,请稍后再试」,已产出的内容也不会落库。

- 新增 StepBudgetMiddleware:按模型调用轮数计账(agent_rounds =
  max_steps // 2),剩余 <=4 轮时注入一次「立刻停止调用工具、给出结论」
  的收尾提示,只提醒一次
- 新增 STEP_GRACE(20),recursion_limit = max_steps + STEP_GRACE,把余量
  留给收尾动作
- GraphRecursionError 统一转成 StepBudgetExceeded,ainvoke 与流式两条
  路径都覆盖
- AgentReply 把「步数用尽」渲染成可操作说明,接在已产出内容之后一并
  下发并落库;用 _reported 标记让 on_error 不再补发通用错误文案,任务
  状态仍如实记 failed
- 同步 README / docs/architecture.md / db/schema.py 中 max_steps 的语义

测试:新增 tests/test_budget.py(7 个用例),全量 241 passed。
2026-11-09 21:32:29 +08:00

303 lines
9.7 KiB
Python

"""流式回复测试:节流、去重、超时续流,以及 AgentReply 的流式链路。"""
from __future__ import annotations
import asyncio
import json
from pathlib import Path
from typing import Any, ClassVar
import pytest
from bot042.agent.middlewares.budget import StepBudgetExceeded
from bot042.channels.base import BaseChannel
from bot042.channels.manager import ChannelManager
from bot042.channels.models import (
ChannelConfig,
ChannelMessage,
ChannelSubject,
InboundMessage,
OutboundStream,
TextContent,
)
from bot042.channels.registry import register_channel
from bot042.config import Settings
from bot042.db import repo
from bot042.flows import builtin
from bot042.flows.builtin import BUDGET_REPLY, RPC_STREAM, AgentReply, ChannelServices
from bot042.flows.bus import EventBus
from bot042.flows.rpc import RpcHub
from bot042.flows.stream import ReplyStream
from bot042.flows.tasks import EventTrigger, RunStatus, TaskRunner
def test_stream_sends_ack_and_throttles() -> None:
sent: list[tuple[str, str, bool]] = []
now = [0.0]
async def _send(text: str, *, stream_id: str, finish: bool) -> None:
sent.append((stream_id, text, finish))
stream = ReplyStream(
_send, min_interval=1.0, segment_seconds=540, clock=lambda: now[0]
)
async def _run() -> None:
await stream.update("收到", force=True) # 首帧立即发
now[0] = 0.5
await stream.update("收到,正在") # 节流窗口内被跳过
now[0] = 1.2
await stream.update("收到,正在处理") # 发出
await stream.update("收到,正在处理") # 内容未变,跳过
await stream.finish()
asyncio.run(_run())
assert [t[1] for t in sent] == ["收到", "收到,正在处理", "收到,正在处理"]
assert [t[2] for t in sent] == [False, False, True]
assert len({t[0] for t in sent}) == 1
def test_stream_rollover_after_segment_limit() -> None:
"""超过平台存活上限时,结束旧流并另起一段。"""
sent: list[tuple[str, str, bool]] = []
now = [0.0]
async def _send(text: str, *, stream_id: str, finish: bool) -> None:
sent.append((stream_id, text, finish))
stream = ReplyStream(
_send, min_interval=0.0, segment_seconds=10, clock=lambda: now[0]
)
async def _run() -> None:
await stream.update("第一段", force=True)
now[0] = 11.0
await stream.update("第一段第二段") # 触发续流
await stream.finish()
asyncio.run(_run())
assert stream.segments == 2
stream_ids = {sid for sid, _, _ in sent}
assert len(stream_ids) == 2
# 旧段以 finish 收尾,新段首帧立刻铺上已有内容
first_id = sent[0][0]
assert (first_id, "第一段第二段", True) in sent
assert sent[-1][2] is True
def test_stream_ignores_send_failure() -> None:
"""单次推送失败不能打断生成。"""
sent: list[str] = []
async def _send(text: str, *, stream_id: str, finish: bool) -> None:
if not finish:
raise RuntimeError("boom")
sent.append(text)
stream = ReplyStream(_send, min_interval=0.0)
async def _run() -> None:
await stream.update("一半", force=True)
await stream.finish("完整答案")
asyncio.run(_run())
assert sent == ["完整答案"]
class StreamConfig(ChannelConfig):
pass
class StreamChannel(BaseChannel):
"""支持流式的测试渠道:记录每次 reply_stream 调用。"""
channel_type = "stream-test"
supports_stream = True
instances: ClassVar[list[StreamChannel]] = []
def __init__(
self,
processor: Any = None,
*,
config: StreamConfig | None = None,
channel_id: str | None = None,
**kwargs: Any,
) -> None:
super().__init__(processor, config=config, channel_id=channel_id, **kwargs)
self.frames: list[tuple[str, bool]] = []
StreamChannel.instances.append(self)
async def start(self) -> None:
pass
async def stop(self) -> None:
pass
def parse_inbound(self, raw_payload: Any) -> InboundMessage:
if isinstance(raw_payload, InboundMessage):
return raw_payload
return InboundMessage(
channel_id=self.channel_id,
channel_type=self.channel_type,
channel_subject=ChannelSubject(subject_id="u1"),
content=[TextContent(text=str(raw_payload))],
)
def get_subject(self, subject_id: str) -> ChannelSubject | None:
return ChannelSubject(subject_id=subject_id)
async def reply_stream(
self, subject: ChannelSubject, text: str, *, stream_id: str, finish: bool = False
) -> None:
self.frames.append((text, finish))
async def _send_text(self, subject: ChannelSubject, text: str) -> None:
self.frames.append((text, True))
async def _send_content(self, subject: ChannelSubject, parts: list) -> None:
pass
async def _send_media(self, subject: ChannelSubject, media: Any) -> None:
pass
register_channel("stream-test", StreamChannel, StreamConfig)
def test_agent_reply_acks_then_streams(
monkeypatch: pytest.MonkeyPatch, tmp_path: Path
) -> None:
"""收到消息先 ack,随后逐步覆盖,最后以 finish 收尾。"""
StreamChannel.instances.clear()
async def fake_stream(task, settings=None, history=None, *, cache=None, steering=None):
for text in ("你", "你好"):
yield text
monkeypatch.setattr(builtin, "stream_task", fake_stream)
async def _run() -> list[tuple[str, bool]]:
bus = EventBus()
bus.bind_loop()
hub = RpcHub(bus)
manager = ChannelManager()
channel = StreamChannel(channel_id="s1")
await manager.add_channel(channel)
await manager.start()
_ = hub.serve(RPC_STREAM, manager.rpc_stream)
services = ChannelServices(
channels=manager,
settings=Settings(),
db=tmp_path / "bot.db",
hub=hub,
)
runner = TaskRunner(bus, deps=services)
runner.register(AgentReply)
_ = runner.add_task(AgentReply.name, EventTrigger(event="channel.inbound"))
await runner.start()
bus.emit(
"channel.inbound",
ChannelMessage.of(
InboundMessage(
channel_id="s1",
channel_type="stream-test",
channel_subject=ChannelSubject(subject_id="u1"),
content=[TextContent(text="你好")],
)
),
)
await asyncio.sleep(0.05) # 等 handler 真正开始派发
await runner.wait_idle()
await runner.stop()
hub.close()
await manager.stop()
return channel.frames
frames = asyncio.run(_run())
# 首帧 ack,首段内容立即覆盖(跳过节流),最后以 finish 收尾
assert frames[0] == (builtin.ACK_TEXT, False)
assert frames[1] == ("你", False)
assert frames[-1] == ("你好", True)
def test_agent_reply_streams_budget_notice_after_partial(
monkeypatch: pytest.MonkeyPatch, tmp_path: Path
) -> None:
"""步数用尽:说明补在已流出的内容后面,落库,且不再补发通用错误文案。"""
StreamChannel.instances.clear()
async def exhausted(task, settings=None, history=None, *, cache=None, steering=None):
yield "做到一半"
raise StepBudgetExceeded(200)
monkeypatch.setattr(builtin, "stream_task", exhausted)
async def _run() -> tuple[list[tuple[str, bool]], list[RunStatus]]:
bus = EventBus()
bus.bind_loop()
hub = RpcHub(bus)
manager = ChannelManager()
channel = StreamChannel(channel_id="s1")
await manager.add_channel(channel)
await manager.start()
_ = hub.serve(RPC_STREAM, manager.rpc_stream)
services = ChannelServices(
channels=manager,
settings=Settings(),
db=tmp_path / "bot.db",
hub=hub,
)
runner = TaskRunner(bus, deps=services)
runner.register(AgentReply)
_ = runner.add_task(AgentReply.name, EventTrigger(event="channel.inbound"))
await runner.start()
bus.emit(
"channel.inbound",
ChannelMessage.of(
InboundMessage(
channel_id="s1",
channel_type="stream-test",
channel_subject=ChannelSubject(subject_id="u1"),
content=[TextContent(text="把整站重构一遍")],
)
),
)
await asyncio.sleep(0.05)
await runner.wait_idle()
statuses = [run.status for run in runner.runs(AgentReply.name)]
await runner.stop()
hub.close()
await manager.stop()
return channel.frames, statuses
frames, statuses = asyncio.run(_run())
final = "做到一半\n\n" + BUDGET_REPLY.format(steps=200)
assert frames[0] == (builtin.ACK_TEXT, False)
assert frames[-1] == (final, True) # 收尾帧保留了部分内容 + 说明
assert statuses == [RunStatus.FAILED]
rows = asyncio.run(repo.list_messages(tmp_path / "bot.db", session_id="s1:u1"))
assert rows[-1]["role"] == "assistant"
assert rows[-1]["content"] == final
def test_outbound_stream_payload_defaults() -> None:
payload = OutboundStream(
channel_id="c", subject_id="u", stream_id="s", text="x"
)
assert payload.finish is False
assert payload.metadata == {}
def test_manager_rejects_unknown_stream_payload() -> None:
manager = ChannelManager()
async def _run() -> None:
with pytest.raises(TypeError):
await manager.rpc_stream(json.dumps({"x": 1}))
asyncio.run(_run())