- agent: 新增 base.py 执行基类、execution.py 执行器、web.py 网络工具, middlewares/steering.py 中间件;移除旧的 agent.py - channels: 新增 ChannelManager、registry、models 与 IM 渠道(企业微信), 扩展 base.py - flows: 新增 agent_task / bus / cron / scheduler / service / stream / rpc / processor / tasks / model_settings / builtin;移除旧的 task.py - db: 新增 sqlite schema 与 repo 层 - docs: 新增架构说明、Channel × EventBus 设计、任务编写教程 - 依赖新增 aiosqlite / httpx / langgraph / primp / pydantic / ripgrep / wecom-aibot-sdk;新增 bot 命令入口 - 测试:232 passed
313 lines
10 KiB
Python
313 lines
10 KiB
Python
"""channels 协议对象与 BaseChannel 模板测试。"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import asyncio
|
|
import base64
|
|
from typing import Any
|
|
|
|
import pytest
|
|
|
|
from bot042.channels.base import (
|
|
ERROR_FALLBACK_TEXT,
|
|
BaseChannel,
|
|
ChannelCredentialsError,
|
|
)
|
|
from bot042.channels.models import (
|
|
ChannelConfig,
|
|
ChannelRuntimeStatus,
|
|
ChannelSubject,
|
|
ImageContent,
|
|
InboundMessage,
|
|
MessageEvent,
|
|
MessageEventType,
|
|
TextContent,
|
|
)
|
|
|
|
|
|
class DummyChannel(BaseChannel):
|
|
channel_type = "dummy"
|
|
|
|
def __init__(self, **kwargs: Any) -> None:
|
|
super().__init__(**kwargs)
|
|
self.sent: list[tuple[str, str]] = []
|
|
|
|
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,
|
|
content=[TextContent(text=str(raw_payload))],
|
|
channel_subject=ChannelSubject(subject_id="u1"),
|
|
)
|
|
|
|
async def _send_text(self, subject: ChannelSubject, text: str) -> None:
|
|
self.sent.append(("text", text))
|
|
|
|
async def _send_content(self, subject: ChannelSubject, parts: list) -> None:
|
|
self.sent.append(("content", str(len(parts))))
|
|
|
|
async def _send_media(self, subject: ChannelSubject, media: Any) -> None:
|
|
self.sent.append(("media", media.type))
|
|
|
|
|
|
def _message(text: str = "hi") -> InboundMessage:
|
|
return InboundMessage(
|
|
channel_id="dummy",
|
|
content=[TextContent(text=text)],
|
|
channel_subject=ChannelSubject(subject_id="u1", display_name="U"),
|
|
)
|
|
|
|
|
|
# --------------------------------------------------------------------- models
|
|
|
|
|
|
def test_inbound_message_text_and_media() -> None:
|
|
msg = InboundMessage(
|
|
channel_id="c1",
|
|
content=[TextContent(text="hi"), TextContent(text="there"), ImageContent(url="u")],
|
|
)
|
|
assert msg.text == "hi\nthere"
|
|
assert msg.has_media is True
|
|
|
|
|
|
def test_message_event_factories() -> None:
|
|
assert MessageEvent.text("x").type == MessageEventType.MESSAGE
|
|
assert MessageEvent.delta("x").type == MessageEventType.DELTA
|
|
assert MessageEvent.typing().type == MessageEventType.TYPING
|
|
assert MessageEvent.flush().type == MessageEventType.FLUSH
|
|
assert MessageEvent.thinking("t").type == MessageEventType.THINKING
|
|
assert MessageEvent.thinking_delta("t").type == MessageEventType.THINKING_DELTA
|
|
assert MessageEvent.tool_start("t").metadata["tool_name"] == "t"
|
|
assert MessageEvent.tool_end("t").metadata["tool_name"] == "t"
|
|
assert MessageEvent.completed().type == MessageEventType.COMPLETED
|
|
assert MessageEvent.error_event("boom").error == "boom"
|
|
|
|
|
|
def test_channel_config_from_dict_and_credentials() -> None:
|
|
class DemoConfig(ChannelConfig):
|
|
api_key: str = ""
|
|
required_credentials = ("api_key",)
|
|
|
|
cfg = DemoConfig.from_dict({"api_key": " k ", "unknown": 1})
|
|
assert cfg.api_key == "k"
|
|
assert cfg.missing_credentials() == []
|
|
assert DemoConfig().missing_credentials() == ["api_key"]
|
|
|
|
|
|
def test_credentials_error_fields() -> None:
|
|
exc = ChannelCredentialsError("wecom", ["bot_id", "secret"])
|
|
assert exc.kind == "wecom"
|
|
assert exc.missing == ["bot_id", "secret"]
|
|
assert isinstance(exc, ValueError)
|
|
|
|
|
|
def test_runtime_status_defaults() -> None:
|
|
st = ChannelRuntimeStatus()
|
|
assert st.connected is False
|
|
assert st.reason is None
|
|
|
|
|
|
# ----------------------------------------------------------------- BaseChannel
|
|
|
|
|
|
def test_handle_inbound_accumulates_deltas() -> None:
|
|
async def processor(msg: InboundMessage):
|
|
yield MessageEvent.delta("Hello ")
|
|
yield MessageEvent.delta("World")
|
|
yield MessageEvent.completed()
|
|
|
|
channel = DummyChannel(processor=processor)
|
|
asyncio.run(channel.handle_inbound(_message()))
|
|
assert channel.sent == [("text", "Hello World")]
|
|
assert channel.get_subject("u1") is not None
|
|
|
|
|
|
def test_handle_inbound_flush_splits_messages() -> None:
|
|
async def processor(msg: InboundMessage):
|
|
yield MessageEvent.delta("part1")
|
|
yield MessageEvent.flush()
|
|
yield MessageEvent.delta("part2")
|
|
yield MessageEvent.completed()
|
|
|
|
channel = DummyChannel(processor=processor)
|
|
asyncio.run(channel.handle_inbound(_message()))
|
|
assert channel.sent == [("text", "part1"), ("text", "part2")]
|
|
|
|
|
|
def test_handle_inbound_message_event_immediate() -> None:
|
|
async def processor(msg: InboundMessage):
|
|
yield MessageEvent.delta("buffered")
|
|
yield MessageEvent.text("now")
|
|
yield MessageEvent.completed()
|
|
|
|
channel = DummyChannel(processor=processor)
|
|
asyncio.run(channel.handle_inbound(_message()))
|
|
assert channel.sent == [("text", "buffered"), ("text", "now")]
|
|
|
|
|
|
def test_handle_inbound_thinking_gated_by_config() -> None:
|
|
async def processor(msg: InboundMessage):
|
|
yield MessageEvent.thinking("why")
|
|
yield MessageEvent.thinking_delta("why2")
|
|
yield MessageEvent.text("answer")
|
|
yield MessageEvent.completed()
|
|
|
|
hidden = DummyChannel(processor=processor)
|
|
asyncio.run(hidden.handle_inbound(_message()))
|
|
assert hidden.sent == [("text", "answer")]
|
|
|
|
shown = DummyChannel(processor=processor, config=ChannelConfig(show_thinking=True))
|
|
asyncio.run(shown.handle_inbound(_message()))
|
|
assert ("text", "[思考] why") in shown.sent
|
|
assert ("text", "[思考] why2") in shown.sent
|
|
|
|
|
|
def test_handle_inbound_tool_hints() -> None:
|
|
async def processor(msg: InboundMessage):
|
|
yield MessageEvent.tool_start("t1")
|
|
yield MessageEvent.tool_end("t1")
|
|
yield MessageEvent.completed()
|
|
|
|
channel = DummyChannel(processor=processor)
|
|
asyncio.run(channel.handle_inbound(_message()))
|
|
assert channel.sent == [("text", "[工具] t1 开始执行"), ("text", "[工具] t1 执行完成")]
|
|
|
|
|
|
def test_handle_inbound_error_event_stops_stream() -> None:
|
|
async def processor(msg: InboundMessage):
|
|
yield MessageEvent.delta("leftover")
|
|
yield MessageEvent.error_event("出错了")
|
|
yield MessageEvent.text("never")
|
|
yield MessageEvent.completed()
|
|
|
|
channel = DummyChannel(processor=processor)
|
|
asyncio.run(channel.handle_inbound(_message()))
|
|
assert channel.sent == [("text", "leftover"), ("text", "出错了")]
|
|
|
|
|
|
def test_handle_inbound_processor_exception_falls_back() -> None:
|
|
async def processor(msg: InboundMessage):
|
|
yield MessageEvent.delta("partial")
|
|
raise RuntimeError("boom")
|
|
|
|
channel = DummyChannel(processor=processor)
|
|
asyncio.run(channel.handle_inbound(_message()))
|
|
assert channel.sent == [
|
|
("text", "partial"),
|
|
("text", "处理消息时出错,请稍后再试。"),
|
|
]
|
|
|
|
|
|
def test_handle_inbound_requires_processor() -> None:
|
|
channel = DummyChannel()
|
|
with pytest.raises(RuntimeError, match="未配置消息处理器"):
|
|
asyncio.run(channel.handle_inbound(_message()))
|
|
|
|
|
|
def test_merge_inbound_and_session_key() -> None:
|
|
channel = DummyChannel()
|
|
m1 = InboundMessage(
|
|
channel_id="d",
|
|
content=[TextContent(text="a")],
|
|
channel_subject=ChannelSubject(subject_id="u1"),
|
|
)
|
|
m2 = InboundMessage(
|
|
channel_id="d",
|
|
content=[TextContent(text="b")],
|
|
channel_subject=ChannelSubject(subject_id="u1"),
|
|
)
|
|
merged = channel.merge_inbound([m1, m2])
|
|
assert merged.text == "a\nb"
|
|
assert channel.get_session_key(m1) == "u1"
|
|
assert channel.should_batch_inbound(m1) is True
|
|
|
|
|
|
def test_merge_inbound_keeps_runtime_metadata_by_reference() -> None:
|
|
"""合批不能深拷贝 metadata:里面可能挂着不可拷贝的渠道运行时对象。"""
|
|
channel = DummyChannel()
|
|
|
|
class LiveClient:
|
|
def __deepcopy__(self, memo: dict) -> LiveClient:
|
|
raise TypeError("live client cannot be deep-copied")
|
|
|
|
client = LiveClient()
|
|
m1 = InboundMessage(
|
|
channel_id="d",
|
|
content=[TextContent(text="a")],
|
|
channel_subject=ChannelSubject(subject_id="u1"),
|
|
metadata={"client": client},
|
|
timestamp=2.0,
|
|
)
|
|
m2 = InboundMessage(
|
|
channel_id="d",
|
|
content=[TextContent(text="b")],
|
|
channel_subject=ChannelSubject(subject_id="u1"),
|
|
timestamp=1.0,
|
|
)
|
|
|
|
merged = channel.merge_inbound([m1, m2])
|
|
|
|
assert merged.text == "a\nb"
|
|
assert merged.timestamp == 1.0
|
|
assert merged.metadata["client"] is client # 运行时对象按引用保留
|
|
assert merged.metadata is not m1.metadata # 映射本身独立,改合批结果不影响原消息
|
|
|
|
|
|
def test_load_media_bytes_priority(tmp_path) -> None:
|
|
channel = DummyChannel()
|
|
|
|
inline = ImageContent(data=base64.b64encode(b"img-bytes").decode(), mime_type="image/png")
|
|
raw, mime = asyncio.run(channel.load_media_bytes(inline))
|
|
assert raw == b"img-bytes"
|
|
assert mime == "image/png"
|
|
|
|
file_part = ImageContent(local_path=str(tmp_path / "x.png"))
|
|
(tmp_path / "x.png").write_bytes(b"file-bytes")
|
|
raw, _mime = asyncio.run(channel.load_media_bytes(file_part))
|
|
assert raw == b"file-bytes"
|
|
|
|
with pytest.raises(ValueError, match="data/local_path/url"):
|
|
asyncio.run(channel.load_media_bytes(ImageContent()))
|
|
|
|
|
|
def test_push_subject_merges_known_metadata() -> None:
|
|
channel = DummyChannel()
|
|
known = ChannelSubject(subject_id="u1", display_name="U", chat_type="direct", metadata={"k": "v"})
|
|
channel._known_subjects["u1"] = known
|
|
|
|
resolved = channel.resolve_push_subject(ChannelSubject(subject_id="u1"))
|
|
assert resolved.metadata["k"] == "v"
|
|
assert resolved.display_name == "U"
|
|
assert resolved.chat_type == "direct"
|
|
|
|
|
|
def test_notify_closed_wakes_waiters() -> None:
|
|
channel = DummyChannel()
|
|
|
|
async def _run() -> bool:
|
|
waiter = asyncio.create_task(channel.wait_closed())
|
|
channel.notify_closed()
|
|
await asyncio.wait_for(waiter, timeout=1)
|
|
return True
|
|
|
|
assert asyncio.run(_run()) is True
|
|
|
|
def test_process_inbound_tolerates_sync_processor_error() -> None:
|
|
"""处理器同步抛出:走统一兜底(不发散异常),并给出兜底提示。"""
|
|
|
|
def boom(_msg: InboundMessage):
|
|
raise RuntimeError("boom")
|
|
|
|
channel = DummyChannel(typing_keepalive_interval=0.01)
|
|
channel.attach(lambda payload: None, processor=boom)
|
|
asyncio.run(channel.handle_inbound(_message()))
|
|
|
|
assert channel.sent[-1] == ("text", ERROR_FALLBACK_TEXT)
|