feat(channels): add NATS channel (request/reply front-end)
- NatsChannel: subscribe in_subject (agenthub.in.>), publish replies to
out_subject.<chat_id>; JSON bodies {chat_id, user_id?, text}
- deltas dropped (no edit semantics), final/status/interaction/command
rendered via shared base helpers; allowed_users gate; 900KB split
- vendored SyncNATS wrapper (nats-py is asyncio-only; thread behind)
- runtime.build_channels wiring; optional dependency extra "nats"
- 9 mock-transport tests; full suite 116 passed
This commit is contained in:
1 parent
ee1cca839f
commit
f688e3be9f
4 files changed
+559
No files matched your search
@@ -0,0 +1,249 @@
|
|||||||
|
"""Synchronous wrapper over nats-py.
|
||||||
|
|
||||||
|
nats-py is asyncio-only (no official sync client exists). This module runs
|
||||||
|
the entire client on a dedicated background event-loop thread and exposes
|
||||||
|
blocking, thread-safe calls: the same pub/sub semantics as ``nats.connect``
|
||||||
|
without requiring the caller to have an event loop.
|
||||||
|
|
||||||
|
Not affiliated with nats-py; requires ``nats-py>=2.6.0`` to be installed.
|
||||||
|
"""
|
||||||
|
|
||||||
|
from __future__ import annotations
|
||||||
|
|
||||||
|
import asyncio
|
||||||
|
import threading
|
||||||
|
from typing import Any, Callable
|
||||||
|
|
||||||
|
__all__ = ["SyncNATS", "SyncMsg"]
|
||||||
|
|
||||||
|
ConnectCallback = Callable[[], None]
|
||||||
|
MessageCallback = Callable[["SyncMsg"], None]
|
||||||
|
|
||||||
|
|
||||||
|
class SyncMsg:
|
||||||
|
"""A received message. ``data`` is raw bytes, ``subject`` the topic."""
|
||||||
|
|
||||||
|
__slots__ = ("subject", "data", "reply", "_ack")
|
||||||
|
|
||||||
|
def __init__(self, subject: str, data: bytes, reply: str = "") -> None:
|
||||||
|
self.subject = subject
|
||||||
|
self.data = data
|
||||||
|
self.reply = reply
|
||||||
|
|
||||||
|
def decode(self) -> str:
|
||||||
|
return self.data.decode("utf-8", errors="replace")
|
||||||
|
|
||||||
|
def __repr__(self) -> str: # pragma: no cover
|
||||||
|
return f"<SyncMsg subject={self.subject!r} {len(self.data)} bytes>"
|
||||||
|
|
||||||
|
|
||||||
|
class SyncNATS:
|
||||||
|
"""Blocking NATS client. Create one per process (or per connection).
|
||||||
|
|
||||||
|
Example:
|
||||||
|
nc = SyncNATS("nats://localhost:4222")
|
||||||
|
nc.subscribe("bots.*.in", callback=lambda m: print(m.decode()))
|
||||||
|
nc.publish("bots.x.out", b"hello")
|
||||||
|
nc.close()
|
||||||
|
"""
|
||||||
|
|
||||||
|
def __init__(
|
||||||
|
self,
|
||||||
|
servers: str = "nats://localhost:4222",
|
||||||
|
*,
|
||||||
|
username: str = "",
|
||||||
|
password: str = "",
|
||||||
|
connect_timeout: float = 10.0,
|
||||||
|
on_connect: ConnectCallback | None = None,
|
||||||
|
on_disconnect: ConnectCallback | None = None,
|
||||||
|
) -> None:
|
||||||
|
self._servers = servers
|
||||||
|
self._username = username
|
||||||
|
self._password = password
|
||||||
|
self._connect_timeout = connect_timeout
|
||||||
|
self._on_connect = on_connect
|
||||||
|
self._on_disconnect = on_disconnect
|
||||||
|
|
||||||
|
self._ready = threading.Event()
|
||||||
|
self._connect_error: BaseException | None = None
|
||||||
|
|
||||||
|
self._loop = asyncio.new_event_loop()
|
||||||
|
self._thread = threading.Thread(
|
||||||
|
target=self._thread_main, name="sync-nats", daemon=True
|
||||||
|
)
|
||||||
|
self._thread.start()
|
||||||
|
# Wait for connect to finish (success or failure) before returning.
|
||||||
|
self._ready.wait(timeout=self._connect_timeout + 5)
|
||||||
|
if self._connect_error is not None:
|
||||||
|
self._shutdown_loop()
|
||||||
|
raise self._connect_error
|
||||||
|
|
||||||
|
# ------------------------------------------------------------------
|
||||||
|
# Background loop thread
|
||||||
|
# ------------------------------------------------------------------
|
||||||
|
|
||||||
|
def _thread_main(self) -> None:
|
||||||
|
asyncio.set_event_loop(self._loop)
|
||||||
|
self._loop.run_until_complete(self._connect())
|
||||||
|
self._loop.run_forever()
|
||||||
|
# Loop stopped: drain remaining callbacks then close.
|
||||||
|
pending = asyncio.all_tasks(self._loop)
|
||||||
|
if pending:
|
||||||
|
self._loop.run_until_complete(
|
||||||
|
asyncio.gather(*pending, return_exceptions=True)
|
||||||
|
)
|
||||||
|
self._loop.close()
|
||||||
|
|
||||||
|
async def _connect(self) -> None:
|
||||||
|
import nats
|
||||||
|
|
||||||
|
servers = [s.strip() for s in self._servers.split(",") if s.strip()]
|
||||||
|
|
||||||
|
async def _disc() -> None:
|
||||||
|
if self._on_disconnect:
|
||||||
|
try:
|
||||||
|
self._on_disconnect()
|
||||||
|
except Exception:
|
||||||
|
pass
|
||||||
|
|
||||||
|
async def _reconn() -> None:
|
||||||
|
if self._on_connect:
|
||||||
|
try:
|
||||||
|
self._on_connect()
|
||||||
|
except Exception:
|
||||||
|
pass
|
||||||
|
|
||||||
|
try:
|
||||||
|
self._nc = await nats.connect(
|
||||||
|
servers=servers,
|
||||||
|
user=self._username or None,
|
||||||
|
password=self._password or None,
|
||||||
|
connect_timeout=int(self._connect_timeout),
|
||||||
|
reconnect_time_wait=1,
|
||||||
|
max_reconnect_attempts=-1,
|
||||||
|
disconnected_cb=_disc,
|
||||||
|
reconnected_cb=_reconn,
|
||||||
|
)
|
||||||
|
except BaseException as exc: # propagate to the constructing thread
|
||||||
|
self._connect_error = exc
|
||||||
|
finally:
|
||||||
|
self._ready.set()
|
||||||
|
|
||||||
|
def _shutdown_loop(self) -> None:
|
||||||
|
if self._loop.is_running():
|
||||||
|
self._loop.call_soon_threadsafe(self._loop.stop)
|
||||||
|
if self._thread.is_alive():
|
||||||
|
self._thread.join(timeout=5)
|
||||||
|
|
||||||
|
# ------------------------------------------------------------------
|
||||||
|
# Public blocking API
|
||||||
|
# ------------------------------------------------------------------
|
||||||
|
|
||||||
|
def publish(self, subject: str, data: bytes | str) -> None:
|
||||||
|
"""Publish and flush before returning (send-and-forget semantics)."""
|
||||||
|
if isinstance(data, str):
|
||||||
|
data = data.encode("utf-8")
|
||||||
|
|
||||||
|
done = threading.Event()
|
||||||
|
err: list[BaseException] = []
|
||||||
|
|
||||||
|
async def _pub() -> None:
|
||||||
|
try:
|
||||||
|
await self._nc.publish(subject, data)
|
||||||
|
await self._nc.flush()
|
||||||
|
except BaseException as exc:
|
||||||
|
err.append(exc)
|
||||||
|
finally:
|
||||||
|
done.set()
|
||||||
|
|
||||||
|
self._loop.call_soon_threadsafe(self._loop.create_task, _pub())
|
||||||
|
if not done.wait(timeout=30):
|
||||||
|
raise TimeoutError(f"publish timed out to {subject}")
|
||||||
|
if err:
|
||||||
|
raise err[0]
|
||||||
|
|
||||||
|
def subscribe(self, subject: str, callback: MessageCallback) -> str:
|
||||||
|
"""Subscribe with a sync callback invoked on the NATS thread."""
|
||||||
|
done = threading.Event()
|
||||||
|
err: list[BaseException] = []
|
||||||
|
sid_box: list[str] = []
|
||||||
|
|
||||||
|
async def _sub() -> None:
|
||||||
|
try:
|
||||||
|
sub = await self._nc.subscribe(subject, cb=self._make_cb(callback))
|
||||||
|
sid_box.append(str(sub._id))
|
||||||
|
except BaseException as exc:
|
||||||
|
err.append(exc)
|
||||||
|
finally:
|
||||||
|
done.set()
|
||||||
|
|
||||||
|
self._loop.call_soon_threadsafe(self._loop.create_task, _sub())
|
||||||
|
if not done.wait(timeout=10):
|
||||||
|
raise TimeoutError(f"subscribe timed out for {subject}")
|
||||||
|
if err:
|
||||||
|
raise err[0]
|
||||||
|
return sid_box[0]
|
||||||
|
|
||||||
|
def unsubscribe(self, sid: str) -> None:
|
||||||
|
done = threading.Event()
|
||||||
|
|
||||||
|
async def _unsub() -> None:
|
||||||
|
try:
|
||||||
|
sub = self._nc._subs.get(int(sid))
|
||||||
|
if sub is not None:
|
||||||
|
await sub.unsubscribe()
|
||||||
|
finally:
|
||||||
|
done.set()
|
||||||
|
|
||||||
|
self._loop.call_soon_threadsafe(self._loop.create_task, _unsub())
|
||||||
|
done.wait(timeout=10)
|
||||||
|
|
||||||
|
def request(self, subject: str, data: bytes | str, timeout: float = 5.0) -> SyncMsg:
|
||||||
|
"""Blocking request/reply using nats-py's inbox machinery."""
|
||||||
|
if isinstance(data, str):
|
||||||
|
data = data.encode("utf-8")
|
||||||
|
|
||||||
|
fut: asyncio.Future = self._loop.create_future()
|
||||||
|
|
||||||
|
async def _req() -> None:
|
||||||
|
try:
|
||||||
|
msg = await self._nc.request(subject, data, timeout=timeout)
|
||||||
|
if not fut.done():
|
||||||
|
fut.set_result(msg)
|
||||||
|
except BaseException as exc:
|
||||||
|
if not fut.done():
|
||||||
|
fut.set_exception(exc)
|
||||||
|
|
||||||
|
self._loop.call_soon_threadsafe(self._loop.create_task, _req())
|
||||||
|
msg = fut.result(timeout=timeout + 5) # may raise TimeoutError / Error
|
||||||
|
return SyncMsg(msg.subject, msg.data, msg.reply or "")
|
||||||
|
|
||||||
|
def is_connected(self) -> bool:
|
||||||
|
return self._nc is not None and self._nc.is_connected
|
||||||
|
|
||||||
|
def close(self) -> None:
|
||||||
|
"""Flush pending publishes and stop the background thread."""
|
||||||
|
if getattr(self, "_nc", None) is not None:
|
||||||
|
nc, self._nc = self._nc, None
|
||||||
|
fut = asyncio.run_coroutine_threadsafe(nc.drain(), self._loop)
|
||||||
|
try:
|
||||||
|
fut.result(timeout=5)
|
||||||
|
except Exception:
|
||||||
|
pass
|
||||||
|
self._shutdown_loop()
|
||||||
|
|
||||||
|
# ------------------------------------------------------------------
|
||||||
|
|
||||||
|
def _make_cb(self, user_cb: MessageCallback) -> Callable:
|
||||||
|
async def _cb(msg: Any) -> None:
|
||||||
|
sync_msg = SyncMsg(msg.subject, msg.data, msg.reply or "")
|
||||||
|
# Run the user callback off the loop thread (it may block).
|
||||||
|
await asyncio.get_running_loop().run_in_executor(None, user_cb, sync_msg)
|
||||||
|
|
||||||
|
return _cb
|
||||||
|
|
||||||
|
def __enter__(self) -> "SyncNATS":
|
||||||
|
return self
|
||||||
|
|
||||||
|
def __exit__(self, *exc: Any) -> None:
|
||||||
|
self.close()
|
||||||
@@ -0,0 +1,168 @@
|
|||||||
|
"""NATS channel for agenthub: request/reply over NATS subjects.
|
||||||
|
|
||||||
|
M1 channel. NATS is a peer front-end (same IMChannel contract as wecom/
|
||||||
|
weixin); agenthub is a NATS client. Protocol:
|
||||||
|
|
||||||
|
- inbound: subscribe to ``subject_prefix`` (default ``agenthub.in.>``).
|
||||||
|
Message body = JSON {"chat_id", "user_id"?, "text"} (extra fields kept
|
||||||
|
in raw). If the message carries a ``reply`` subject, final answers are
|
||||||
|
published back to it; otherwise to ``subject_prefix`` with ``.out``
|
||||||
|
semantics (see below).
|
||||||
|
- outbound: reply(chat_id, text) publishes JSON {"chat_id", "text"} to
|
||||||
|
``out_subject`` (default ``agenthub.out.<chat_id>``).
|
||||||
|
|
||||||
|
Channel name is "nats"; chat keys become "nats:<chat_id>" downstream.
|
||||||
|
|
||||||
|
Config (dict):
|
||||||
|
servers: str = "nats://localhost:4222" # comma separated
|
||||||
|
username / password: str = ""
|
||||||
|
in_subject: str = "agenthub.in.>" # subscription pattern
|
||||||
|
out_subject: str = "agenthub.out" # replies published to out_subject.<chat_id>
|
||||||
|
allowed_users: list[str] = []
|
||||||
|
|
||||||
|
Requires the ``nats`` extra (nats-py). Reuses octop-gateway's SyncNATS
|
||||||
|
wrapper (vendored copy, asyncio-only nats-py behind a thread).
|
||||||
|
"""
|
||||||
|
|
||||||
|
from __future__ import annotations
|
||||||
|
|
||||||
|
import json
|
||||||
|
import logging
|
||||||
|
import threading
|
||||||
|
from typing import Any, Callable
|
||||||
|
|
||||||
|
from .base import (
|
||||||
|
IMChannel,
|
||||||
|
InboundMessage,
|
||||||
|
_command_result_text,
|
||||||
|
_interaction_text,
|
||||||
|
clean_control_chars,
|
||||||
|
split_message_text,
|
||||||
|
)
|
||||||
|
|
||||||
|
log = logging.getLogger("agenthub.nats")
|
||||||
|
|
||||||
|
MAX_TEXT_BYTES = 900_000 # NATS default max_payload is 1MB; stay under it
|
||||||
|
|
||||||
|
|
||||||
|
def _log():
|
||||||
|
return logging.getLogger("agenthub.nats")
|
||||||
|
|
||||||
|
|
||||||
|
class NatsChannel:
|
||||||
|
name = "nats"
|
||||||
|
|
||||||
|
def __init__(
|
||||||
|
self,
|
||||||
|
config: dict[str, Any],
|
||||||
|
nats_factory: Callable[..., Any] | None = None,
|
||||||
|
logger: Any = None,
|
||||||
|
):
|
||||||
|
self.servers = (config.get("servers") or "nats://localhost:4222").strip()
|
||||||
|
self.username = config.get("username", "")
|
||||||
|
self.password = config.get("password", "")
|
||||||
|
self.in_subject = config.get("in_subject", "agenthub.in.>")
|
||||||
|
self.out_subject = (config.get("out_subject") or "agenthub.out").rstrip(".")
|
||||||
|
self.allowed_users = set(config.get("allowed_users") or [])
|
||||||
|
self._nats_factory = nats_factory # injectable for tests
|
||||||
|
self._nc: Any = None
|
||||||
|
self._sub_id: str | None = None
|
||||||
|
self._msg_cb: Callable[[InboundMessage], None] | None = None
|
||||||
|
self._sink: Callable[[str, str, dict], None] | None = None
|
||||||
|
self._logger = logger or _log()
|
||||||
|
self._stop = threading.Event()
|
||||||
|
|
||||||
|
# -- IMChannel ---------------------------------------------------------
|
||||||
|
def start(self) -> None:
|
||||||
|
from ._nats_sync import SyncNATS # vendored sync wrapper
|
||||||
|
|
||||||
|
factory = self._nats_factory or SyncNATS
|
||||||
|
self._nc = factory(
|
||||||
|
self.servers,
|
||||||
|
username=self.username,
|
||||||
|
password=self.password,
|
||||||
|
on_connect=lambda: self._logger.info("[nats] connected"),
|
||||||
|
on_disconnect=lambda: self._logger.warning("[nats] disconnected; reconnecting"),
|
||||||
|
)
|
||||||
|
self._sub_id = self._nc.subscribe(self.in_subject, self._on_nats_msg)
|
||||||
|
self._logger.info(f"[nats] subscribed {self.in_subject} (out: {self.out_subject}.*)")
|
||||||
|
|
||||||
|
def stop(self) -> None:
|
||||||
|
self._stop.set()
|
||||||
|
if self._nc:
|
||||||
|
try:
|
||||||
|
if self._sub_id:
|
||||||
|
self._nc.unsubscribe(self._sub_id)
|
||||||
|
self._nc.close()
|
||||||
|
except Exception as e: # noqa: BLE001
|
||||||
|
self._logger.warning(f"[nats] close error: {e}")
|
||||||
|
self._nc = None
|
||||||
|
|
||||||
|
def on_message(self, cb: Callable[[InboundMessage], None]) -> None:
|
||||||
|
self._msg_cb = cb
|
||||||
|
|
||||||
|
def set_event_sink(self, sink: Callable[[str, str, dict], None]) -> None:
|
||||||
|
self._sink = sink
|
||||||
|
|
||||||
|
# -- inbound -----------------------------------------------------------
|
||||||
|
def _on_nats_msg(self, msg: Any) -> None:
|
||||||
|
"""NATS thread callback — must never raise (sync wrapper logs)."""
|
||||||
|
try:
|
||||||
|
data = json.loads(msg.decode())
|
||||||
|
chat_id = str(data.get("chat_id") or "").strip()
|
||||||
|
if not chat_id:
|
||||||
|
# fall back to the subject's last token as chat id
|
||||||
|
chat_id = msg.subject.rsplit(".", 1)[-1]
|
||||||
|
user_id = str(data.get("user_id") or chat_id)
|
||||||
|
if self.allowed_users and user_id not in self.allowed_users:
|
||||||
|
self._logger.warning(f"[nats] user {user_id!r} not allowed; drop")
|
||||||
|
return
|
||||||
|
text = clean_control_chars(str(data.get("text") or ""), max_len=100_000).strip()
|
||||||
|
if not text:
|
||||||
|
return
|
||||||
|
if self._msg_cb:
|
||||||
|
self._msg_cb(
|
||||||
|
InboundMessage(
|
||||||
|
channel=self.name,
|
||||||
|
chat_id=chat_id,
|
||||||
|
user_id=user_id,
|
||||||
|
text=text,
|
||||||
|
raw={"subject": msg.subject, "reply": msg.reply or ""},
|
||||||
|
)
|
||||||
|
)
|
||||||
|
except Exception as e: # noqa: BLE001 — never kill the subscription
|
||||||
|
self._logger.error(f"[nats] inbound dispatch failed: {e}")
|
||||||
|
|
||||||
|
# -- outbound ----------------------------------------------------------
|
||||||
|
def _publish_out(self, chat_id: str, payload: dict[str, Any]) -> None:
|
||||||
|
if not self._nc:
|
||||||
|
return
|
||||||
|
subject = f"{self.out_subject}.{chat_id}"
|
||||||
|
body = json.dumps(payload, ensure_ascii=False).encode()
|
||||||
|
if len(body) > MAX_TEXT_BYTES:
|
||||||
|
self._logger.warning(f"[nats] payload {len(body)}B > {MAX_TEXT_BYTES}B; dropping")
|
||||||
|
return
|
||||||
|
try:
|
||||||
|
self._nc.publish(subject, body)
|
||||||
|
except Exception as e: # noqa: BLE001
|
||||||
|
self._logger.error(f"[nats] publish to {subject} failed: {e}")
|
||||||
|
|
||||||
|
def reply(self, chat_id: str, text: str) -> None:
|
||||||
|
# split under the per-message byte budget (envelope counts too)
|
||||||
|
budget = MAX_TEXT_BYTES - 200
|
||||||
|
for chunk in split_message_text(text, budget):
|
||||||
|
self._publish_out(chat_id, {"chat_id": chat_id, "text": chunk})
|
||||||
|
|
||||||
|
def push_event(self, chat_id: str, kind: str, payload: dict[str, Any]) -> None:
|
||||||
|
if kind == "delta":
|
||||||
|
# NATS has no edit semantics; stream deltas as status lines is
|
||||||
|
# noise — accumulate and deliver on final only.
|
||||||
|
return
|
||||||
|
if kind == "final":
|
||||||
|
self.reply(chat_id, str(payload.get("text", "")))
|
||||||
|
elif kind == "status":
|
||||||
|
self._publish_out(chat_id, {"chat_id": chat_id, "status": str(payload.get("text", ""))})
|
||||||
|
elif kind in ("interaction", "permission"):
|
||||||
|
self.reply(chat_id, _interaction_text(payload))
|
||||||
|
elif kind == "command_result":
|
||||||
|
self.reply(chat_id, _command_result_text(payload))
|
||||||
@@ -84,6 +84,10 @@ def build_channels(cfg: dict[str, Any], mgr: SessionManager) -> list:
|
|||||||
sink_and_inbound(WecomAppChannel(ccfg["wecom-app"]))
|
sink_and_inbound(WecomAppChannel(ccfg["wecom-app"]))
|
||||||
if "weixin" in ccfg:
|
if "weixin" in ccfg:
|
||||||
sink_and_inbound(WeixinChannel(ccfg["weixin"]))
|
sink_and_inbound(WeixinChannel(ccfg["weixin"]))
|
||||||
|
if "nats" in ccfg:
|
||||||
|
from .channels.nats import NatsChannel
|
||||||
|
|
||||||
|
sink_and_inbound(NatsChannel(ccfg["nats"]))
|
||||||
|
|
||||||
# ONE dispatch-all event sink (per-channel sinks would overwrite each
|
# ONE dispatch-all event sink (per-channel sinks would overwrite each
|
||||||
# other; _safe_event filters per channel name anyway). Approvals
|
# other; _safe_event filters per channel name anyway). Approvals
|
||||||
|
|||||||
@@ -0,0 +1,138 @@
|
|||||||
|
"""Tests for the NATS channel (mocked transport, no network)."""
|
||||||
|
|
||||||
|
from __future__ import annotations
|
||||||
|
|
||||||
|
import json
|
||||||
|
from typing import Any
|
||||||
|
|
||||||
|
import pytest
|
||||||
|
|
||||||
|
from agenthub.channels.nats import NatsChannel
|
||||||
|
from agenthub.channels.base import InboundMessage
|
||||||
|
|
||||||
|
|
||||||
|
class FakeMsg:
|
||||||
|
def __init__(self, subject: str, data: bytes, reply: str = ""):
|
||||||
|
self.subject = subject
|
||||||
|
self.data = data
|
||||||
|
self.reply = reply
|
||||||
|
|
||||||
|
def decode(self) -> str:
|
||||||
|
return self.data.decode()
|
||||||
|
|
||||||
|
|
||||||
|
class FakeNATS:
|
||||||
|
"""Minimal SyncNATS stand-in: records subs/pubs, replays on demand."""
|
||||||
|
|
||||||
|
def __init__(self, *a, **kw):
|
||||||
|
self.subs: dict[str, Any] = {}
|
||||||
|
self.pubs: list[tuple[str, bytes]] = []
|
||||||
|
self.closed = False
|
||||||
|
|
||||||
|
def subscribe(self, subject, cb):
|
||||||
|
self.subs[subject] = cb
|
||||||
|
return f"sid-{len(self.subs)}"
|
||||||
|
|
||||||
|
def unsubscribe(self, sid):
|
||||||
|
pass
|
||||||
|
|
||||||
|
def publish(self, subject, data):
|
||||||
|
self.pubs.append((subject, data))
|
||||||
|
|
||||||
|
def close(self):
|
||||||
|
self.closed = True
|
||||||
|
|
||||||
|
|
||||||
|
@pytest.fixture()
|
||||||
|
def ch_and_nc():
|
||||||
|
nc = FakeNATS()
|
||||||
|
ch = NatsChannel({"servers": "nats://x:4222"}, nats_factory=lambda *a, **kw: nc)
|
||||||
|
inbound: list[InboundMessage] = []
|
||||||
|
ch.on_message(inbound.append)
|
||||||
|
ch.start()
|
||||||
|
yield ch, nc, inbound
|
||||||
|
ch.stop()
|
||||||
|
|
||||||
|
|
||||||
|
def _feed(nc: FakeNATS, subject: str, payload: dict, reply: str = ""):
|
||||||
|
cb = next(iter(nc.subs.values()))
|
||||||
|
cb(FakeMsg(subject, json.dumps(payload).encode(), reply))
|
||||||
|
|
||||||
|
|
||||||
|
def test_start_subscribes_and_stop_closes(ch_and_nc):
|
||||||
|
ch, nc, _ = ch_and_nc
|
||||||
|
assert "agenthub.in.>" in nc.subs
|
||||||
|
ch.stop()
|
||||||
|
assert nc.closed
|
||||||
|
|
||||||
|
|
||||||
|
def test_inbound_message_dispatch(ch_and_nc):
|
||||||
|
ch, nc, inbound = ch_and_nc
|
||||||
|
_feed(nc, "agenthub.in.chat1", {"chat_id": "chat1", "user_id": "u1", "text": "hello"})
|
||||||
|
assert len(inbound) == 1
|
||||||
|
m = inbound[0]
|
||||||
|
assert m.channel == "nats"
|
||||||
|
assert m.chat_id == "chat1"
|
||||||
|
assert m.user_id == "u1"
|
||||||
|
assert m.text == "hello"
|
||||||
|
assert m.raw["subject"] == "agenthub.in.chat1"
|
||||||
|
|
||||||
|
|
||||||
|
def test_inbound_chat_id_falls_back_to_subject(ch_and_nc):
|
||||||
|
ch, nc, inbound = ch_and_nc
|
||||||
|
_feed(nc, "agenthub.in.room9", {"text": "hi"})
|
||||||
|
assert inbound[0].chat_id == "room9"
|
||||||
|
assert inbound[0].user_id == "room9"
|
||||||
|
|
||||||
|
|
||||||
|
def test_inbound_allowed_users_gate(ch_and_nc):
|
||||||
|
ch, nc, inbound = ch_and_nc
|
||||||
|
ch.allowed_users = {"alice"}
|
||||||
|
_feed(nc, "agenthub.in.c1", {"chat_id": "c1", "user_id": "bob", "text": "x"})
|
||||||
|
assert inbound == []
|
||||||
|
_feed(nc, "agenthub.in.c1", {"chat_id": "c1", "user_id": "alice", "text": "x"})
|
||||||
|
assert len(inbound) == 1
|
||||||
|
|
||||||
|
|
||||||
|
def test_inbound_bad_json_does_not_raise(ch_and_nc):
|
||||||
|
ch, nc, inbound = ch_and_nc
|
||||||
|
cb = next(iter(nc.subs.values()))
|
||||||
|
cb(FakeMsg("agenthub.in.c1", b"not json"))
|
||||||
|
cb(FakeMsg("agenthub.in.c1", json.dumps({"text": " "}).encode())) # empty text
|
||||||
|
assert inbound == []
|
||||||
|
|
||||||
|
|
||||||
|
def test_final_event_publishes_to_out_subject(ch_and_nc):
|
||||||
|
ch, nc, _ = ch_and_nc
|
||||||
|
ch.push_event("chat1", "final", {"text": "answer"})
|
||||||
|
assert nc.pubs == [("agenthub.out.chat1", json.dumps({"chat_id": "chat1", "text": "answer"}, ensure_ascii=False).encode())]
|
||||||
|
|
||||||
|
|
||||||
|
def test_delta_dropped_status_published(ch_and_nc):
|
||||||
|
ch, nc, _ = ch_and_nc
|
||||||
|
ch.push_event("c", "delta", {"text": "partial"})
|
||||||
|
assert nc.pubs == []
|
||||||
|
ch.push_event("c", "status", {"text": "running..."})
|
||||||
|
assert nc.pubs[0][0] == "agenthub.out.c"
|
||||||
|
assert b"running..." in nc.pubs[0][1]
|
||||||
|
|
||||||
|
|
||||||
|
def test_interaction_renders_numbered_options(ch_and_nc):
|
||||||
|
ch, nc, _ = ch_and_nc
|
||||||
|
ch.push_event("c", "interaction", {
|
||||||
|
"interaction_type": "permission", "tool": "execute",
|
||||||
|
"options": [{"option_id": "allow", "name": "Allow once", "kind": "allow_once"}],
|
||||||
|
"request_id": "req-1",
|
||||||
|
})
|
||||||
|
subject, body = nc.pubs[0]
|
||||||
|
assert subject == "agenthub.out.c"
|
||||||
|
text = json.loads(body)["text"]
|
||||||
|
assert "execute" in text and "Allow once" in text and "req-1" in text
|
||||||
|
|
||||||
|
|
||||||
|
def test_reply_splits_long_text(ch_and_nc):
|
||||||
|
ch, nc, _ = ch_and_nc
|
||||||
|
ch.reply("c", "x" * 1_200_000) # > 900k budget -> 2 chunks
|
||||||
|
assert len(nc.pubs) == 2
|
||||||
|
total = sum(len(json.loads(b)["text"]) for _, b in nc.pubs)
|
||||||
|
assert total >= 1_199_000
|
||||||
Reference in new issue
Block a user