"""流式回复测试:节流、去重、超时续流,以及 AgentReply 的流式链路。""" from __future__ import annotations import asyncio import json from pathlib import Path from typing import Any, ClassVar import pytest 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.flows import builtin from bot042.flows.builtin import 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, 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_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())