use rig_core::error::ProviderError;
use rig_core::serve::Dispatch;
use std::{
sync::{
Arc, Mutex,
atomic::{AtomicBool, AtomicUsize, Ordering},
},
task::{Context, Poll},
time::Duration,
};
use futures::{FutureExt, StreamExt, channel::oneshot, future::poll_fn, task::noop_waker_ref};
use serde_json::json;
use super::{
Bus, BusDriver, Dispatcher, EffectStream, ModelHandle, Pending, Registrar, ServingPolicy,
};
use rig_core::effect::{CustomEffect, Key};
use rig_core::serve::{
Reply as CoreReply, Serve,
adapters::{MemoryAdapter, ModelAdapter, ToolAdapter, ToolFn},
};
use rig_core::{
completion::{CompletionRequest, Message},
effect::{
EffectFamily, EffectKind, FamilyDescriptor, HandlerDescriptor, HandlerKey, MemoryOp,
MemoryOutcome, Outcome,
},
error::{ErrorKind, ErrorReport},
id::ConversationId,
memory::InMemoryConversationMemory,
message::AssistantContent,
rerank::{RerankResponse, RerankResult},
streaming::{Item, Relayed, StreamEvent},
test_utils::{MockCompletionModel, MockStreamEvent, MockTurn},
tool::{Tool, ToolContext, ToolExecutionError, ToolOutput},
};
const TIMEOUT: Duration = Duration::from_secs(5);
async fn within<T>(future: impl Future<Output = T>) -> T {
tokio::time::timeout(TIMEOUT, future)
.await
.expect("a dispatch never hangs")
}
fn custom(payload: serde_json::Value) -> EffectKind {
EffectKind::Custom {
kind: Arc::from("test:echo"),
payload,
}
}
fn completion_kind(stream: bool) -> EffectKind {
EffectKind::Completion {
request: CompletionRequest {
model: None,
chat_history: vec![Message::user("hi")],
documents: vec![],
tools: vec![],
temperature: None,
max_tokens: None,
tool_choice: None,
additional_params: None,
output_schema: None,
record_telemetry_content: false,
},
stream,
}
}
struct Echo {
served: Arc<AtomicUsize>,
gate: Mutex<Option<oneshot::Receiver<()>>>,
}
impl Echo {
fn new() -> (Self, Arc<AtomicUsize>) {
let served = Arc::new(AtomicUsize::new(0));
(
Self {
served: served.clone(),
gate: Mutex::new(None),
},
served,
)
}
fn gated() -> (Self, oneshot::Sender<()>) {
let (open, gate) = oneshot::channel();
(
Self {
served: Arc::new(AtomicUsize::new(0)),
gate: Mutex::new(Some(gate)),
},
open,
)
}
}
impl Serve for Echo {
type Family = rig_core::effect::family::Dynamic;
fn descriptor(&self) -> HandlerDescriptor {
HandlerDescriptor {
key: HandlerKey::from("echo"),
family: FamilyDescriptor::Custom {
kind: "test:echo".into(),
},
layers: Vec::new(),
}
}
async fn serve(&self, kind: EffectKind, _dispatch: Dispatch) -> rig_core::serve::Reply {
let gate = self.gate.lock().expect("gate lock").take();
{
if let Some(gate) = gate {
let _ = gate.await;
}
self.served.fetch_add(1, Ordering::SeqCst);
let outcome = match kind {
EffectKind::Custom { payload, .. } => Ok(Outcome::Custom { payload }),
other => Err(ErrorReport::new(
ErrorKind::Internal,
format!("echo received {}", other.name()),
)),
};
rig_core::serve::Reply::Outcome(outcome)
}
}
}
struct Ordered {
served: Arc<Mutex<Vec<u64>>>,
}
impl Serve for Ordered {
type Family = rig_core::effect::family::Dynamic;
fn descriptor(&self) -> HandlerDescriptor {
HandlerDescriptor {
key: HandlerKey::from("ordered"),
family: FamilyDescriptor::Custom {
kind: "test:ordered".into(),
},
layers: Vec::new(),
}
}
async fn serve(&self, kind: EffectKind, _dispatch: Dispatch) -> rig_core::serve::Reply {
let (index, delay) = match &kind {
EffectKind::Custom { payload, .. } => (
payload["index"].as_u64().unwrap_or(0),
payload["delay_ms"].as_u64().unwrap_or(0),
),
_ => (0, 0),
};
tokio::time::sleep(Duration::from_millis(delay)).await;
self.served.lock().expect("order lock").push(index);
rig_core::serve::Reply::Outcome(Ok(Outcome::Custom {
payload: json!(index),
}))
}
}
struct Add;
#[derive(serde::Deserialize)]
struct AddArgs {
a: i64,
b: i64,
}
impl Tool for Add {
const NAME: &'static str = "add";
type Args = AddArgs;
type Output = i64;
type Error = ToolExecutionError;
fn description(&self) -> String {
"adds".into()
}
fn parameters(&self) -> serde_json::Value {
json!({"type": "object", "properties": {"a": {"type": "integer"}, "b": {"type": "integer"}}})
}
async fn call(&self, _context: &mut ToolContext, args: AddArgs) -> Result<i64, Self::Error> {
Ok(args.a + args.b)
}
}
fn spawn(driver: BusDriver) -> tokio::task::JoinHandle<()> {
tokio::spawn(driver)
}
#[tokio::test]
async fn unary_dispatch_round_trips_through_a_spawned_driver() {
let (dispatcher, _registrar, mut driver) = Bus::channel();
let (echo, served) = Echo::new();
driver.register("echo", echo).expect("register");
let task = spawn(driver);
let pending = dispatcher.dispatch(&HandlerKey::from("echo"), custom(json!({"n": 1})));
let id = pending.id();
let outcome = within(pending).await.expect("served");
assert!(matches!(outcome, Outcome::Custom { ref payload } if *payload == json!({"n": 1})));
assert_eq!(served.load(Ordering::SeqCst), 1);
assert_eq!(
id.as_u64(),
1,
"ids start at one and are minted per dispatch"
);
assert_eq!(
dispatcher
.dispatch(&HandlerKey::from("echo"), custom(json!(2)))
.id()
.as_u64(),
2
);
drop(dispatcher);
within(task)
.await
.expect("driver ends when every dispatcher is gone");
}
#[tokio::test]
async fn a_dropped_driver_answers_bus_closed_before_and_after_the_send() {
let (dispatcher, _registrar, driver) = Bus::channel();
drop(driver);
let report = within(dispatcher.dispatch(&HandlerKey::from("echo"), custom(json!(1))))
.await
.expect_err("closed");
assert_eq!(report.kind, ErrorKind::BusClosed);
assert!(!report.retryable);
assert!(dispatcher.is_closed());
let (dispatcher, _registrar) = Bus::new_with(ServingPolicy::default(), |_| {}, drop);
let report = within(dispatcher.dispatch(&HandlerKey::from("echo"), custom(json!(1))))
.await
.expect_err("closed");
assert_eq!(report.kind, ErrorKind::BusClosed);
let mut stream = dispatcher.dispatch_stream(&HandlerKey::from("model"), completion_kind(true));
let first = within(stream.next()).await.expect("one item");
assert_eq!(first.expect_err("closed").kind, ErrorKind::BusClosed);
assert!(within(stream.next()).await.is_none());
}
#[tokio::test]
async fn dropping_the_driver_mid_flight_fails_the_dispatch_with_bus_closed() {
let (dispatcher, _registrar, mut driver) = Bus::channel();
let (echo, _gate_never_opened) = Echo::gated();
driver.register("echo", echo).expect("register");
let mut pending = dispatcher.dispatch(&HandlerKey::from("echo"), custom(json!(1)));
let waker = noop_waker_ref();
let mut cx = Context::from_waker(waker);
assert!(pending.poll_unpin(&mut cx).is_pending());
assert!(driver.poll_unpin(&mut cx).is_pending());
assert_eq!(driver.in_flight(), 1);
drop(driver);
let report = within(pending).await.expect_err("closed mid-flight");
assert_eq!(report.kind, ErrorKind::BusClosed);
}
#[tokio::test]
async fn unknown_and_deregistered_keys_answer_handler_unavailable_with_the_key() {
let (dispatcher, registrar, mut driver) = Bus::channel();
let (echo, _) = Echo::new();
driver.register("echo", echo).expect("register");
let _task = spawn(driver);
let report = within(dispatcher.dispatch(&HandlerKey::from("missing"), custom(json!(1))))
.await
.expect_err("unknown");
assert_eq!(report.kind, ErrorKind::HandlerUnavailable);
assert!(report.message.contains("`missing`"), "{}", report.message);
assert!(!report.retryable);
assert!(registrar.deregister(&HandlerKey::from("echo")));
assert!(!registrar.deregister(&HandlerKey::from("echo")));
let report = within(dispatcher.dispatch(&HandlerKey::from("echo"), custom(json!(1))))
.await
.expect_err("deregistered");
assert_eq!(report.kind, ErrorKind::HandlerUnavailable);
assert!(report.message.contains("`echo`"));
let (echo, served) = Echo::new();
registrar.register("echo", echo).expect("register");
within(dispatcher.dispatch(&HandlerKey::from("echo"), custom(json!(1))))
.await
.expect("re-registered");
assert_eq!(served.load(Ordering::SeqCst), 1);
}
#[tokio::test]
async fn clones_share_the_bus_and_the_driver_outlives_the_original() {
let (dispatcher, _registrar, mut driver) = Bus::channel();
let (echo, served) = Echo::new();
driver.register("echo", echo).expect("register");
let task = spawn(driver);
let clone = dispatcher.clone();
drop(dispatcher);
within(clone.dispatch(&HandlerKey::from("echo"), custom(json!(1))))
.await
.expect("served through the clone");
assert_eq!(served.load(Ordering::SeqCst), 1);
drop(clone);
within(task)
.await
.expect("driver ends after the last clone");
}
#[tokio::test]
async fn descriptor_is_a_snapshot_that_needs_no_driver() {
let (dispatcher, _registrar, mut driver) = Bus::channel();
let (echo, _) = Echo::new();
driver.register("echo", echo).expect("register");
driver
.register("add", ToolAdapter::new(Add))
.expect("register");
let descriptor = dispatcher
.descriptor(&HandlerKey::from("add"))
.expect("registered");
assert_eq!(descriptor.family.family(), EffectFamily::Tool);
assert!(matches!(
descriptor.family,
FamilyDescriptor::Tool { ref name, .. } if name == "add"
));
assert!(dispatcher.descriptor(&HandlerKey::from("nope")).is_none());
assert_eq!(
dispatcher.keys(),
vec![HandlerKey::from("add"), HandlerKey::from("echo")]
);
drop(driver);
}
#[tokio::test]
async fn serial_per_handler_serves_in_arrival_order_and_concurrent_may_not() {
async fn run(serial: bool) -> Vec<u64> {
let served = Arc::new(Mutex::new(Vec::new()));
let (dispatcher, _registrar, mut driver) = Bus::channel_with(ServingPolicy {
serial_per_handler: serial,
..ServingPolicy::default()
});
driver
.register(
"ordered",
Ordered {
served: served.clone(),
},
)
.expect("register");
let _task = spawn(driver);
let key = HandlerKey::from("ordered");
let delays = [40u64, 20, 0];
let pendings: Vec<_> = delays
.iter()
.enumerate()
.map(|(index, delay)| {
dispatcher.dispatch(
&key,
custom(json!({"index": index as u64, "delay_ms": delay})),
)
})
.collect();
within(futures::future::join_all(pendings)).await;
served.lock().expect("order").clone()
}
assert_eq!(run(true).await, vec![0, 1, 2], "serial keeps arrival order");
assert_eq!(
run(false).await,
vec![2, 1, 0],
"concurrent finishes by delay"
);
}
#[tokio::test]
async fn concurrent_serving_across_keys_is_the_default() {
let (dispatcher, _registrar, mut driver) = Bus::channel();
let (blocked, open) = Echo::gated();
let (free, served) = Echo::new();
driver.register("blocked", blocked).expect("register");
driver.register("free", free).expect("register");
let mut blocked_pending = dispatcher.dispatch(&HandlerKey::from("blocked"), custom(json!(1)));
let mut cx = Context::from_waker(noop_waker_ref());
assert!(blocked_pending.poll_unpin(&mut cx).is_pending());
assert!(driver.poll_unpin(&mut cx).is_pending());
assert_eq!(
driver.in_flight(),
1,
"the gated key must actually be serving"
);
let _task = spawn(driver);
let free_outcome = within(dispatcher.dispatch(&HandlerKey::from("free"), custom(json!(2))))
.await
.expect("free key is served while another is gated");
assert!(matches!(free_outcome, Outcome::Custom { ref payload } if *payload == json!(2)));
assert_eq!(served.load(Ordering::SeqCst), 1);
let _ = open.send(());
within(blocked_pending)
.await
.expect("gated key resolves once opened");
}
#[test]
fn dispatch_never_blocks_the_caller_even_when_the_channel_is_full() {
let (dispatcher, _registrar, driver) = Bus::channel_with(ServingPolicy {
command_capacity: 1,
..ServingPolicy::default()
});
let waker = noop_waker_ref();
let mut cx = Context::from_waker(waker);
let key = HandlerKey::from("echo");
let mut first = dispatcher.dispatch(&key, custom(json!(1)));
assert!(first.poll_unpin(&mut cx).is_pending());
assert_eq!(dispatcher.buffered(), 1);
let mut pressured = Vec::new();
for n in 2..20 {
let mut pending = dispatcher.dispatch(&key, custom(json!(n)));
assert!(pending.poll_unpin(&mut cx).is_pending());
pressured.push(pending);
}
assert_eq!(
dispatcher.buffered(),
1,
"the bound is bus-wide: eighteen parked dispatches buffered nothing"
);
drop(driver);
for mut pending in pressured {
match pending.poll_unpin(&mut cx) {
Poll::Ready(Err(report)) => assert_eq!(report.kind, ErrorKind::BusClosed),
other => panic!("expected BusClosed after the driver dropped, got {other:?}"),
}
}
}
#[test]
fn a_dispatch_parked_on_the_bound_is_sent_once_the_driver_drains() {
let (dispatcher, _registrar, mut driver) = Bus::channel_with(ServingPolicy {
command_capacity: 1,
..ServingPolicy::default()
});
let (echo, served) = Echo::new();
driver.register("echo", echo).expect("register");
let waker = noop_waker_ref();
let mut cx = Context::from_waker(waker);
let key = HandlerKey::from("echo");
let mut first = dispatcher.dispatch(&key, custom(json!(1)));
let mut second = dispatcher.dispatch(&key, custom(json!(2)));
assert!(first.poll_unpin(&mut cx).is_pending());
assert!(second.poll_unpin(&mut cx).is_pending());
assert_eq!(
dispatcher.buffered(),
1,
"the second is parked, not buffered"
);
let _ = driver.poll_unpin(&mut cx);
assert_eq!(served.load(Ordering::SeqCst), 1);
assert_eq!(dispatcher.buffered(), 0);
assert!(second.poll_unpin(&mut cx).is_pending());
assert_eq!(
dispatcher.buffered(),
1,
"the parked dispatch sent after the drain"
);
let _ = driver.poll_unpin(&mut cx);
assert_eq!(served.load(Ordering::SeqCst), 2);
assert!(first.poll_unpin(&mut cx).is_ready());
assert!(second.poll_unpin(&mut cx).is_ready());
}
#[test]
fn a_buffered_dispatch_answers_bus_closed_when_the_driver_drops_before_taking_it() {
let (dispatcher, _registrar, driver) = Bus::channel();
let waker = noop_waker_ref();
let mut cx = Context::from_waker(waker);
let mut pending = dispatcher.dispatch(&HandlerKey::from("echo"), custom(json!(1)));
assert!(pending.poll_unpin(&mut cx).is_pending());
assert_eq!(dispatcher.buffered(), 1);
drop(driver);
match pending.poll_unpin(&mut cx) {
Poll::Ready(Err(report)) => assert_eq!(report.kind, ErrorKind::BusClosed),
other => panic!("expected BusClosed, got {other:?}"),
}
assert_eq!(dispatcher.buffered(), 0);
}
#[test]
fn a_dispatch_dropped_while_parked_on_the_bound_sends_nothing() {
let (dispatcher, _registrar, mut driver) = Bus::channel_with(ServingPolicy {
command_capacity: 1,
..ServingPolicy::default()
});
let (echo, served) = Echo::new();
driver.register("echo", echo).expect("register");
let waker = noop_waker_ref();
let mut cx = Context::from_waker(waker);
let key = HandlerKey::from("echo");
let mut first = dispatcher.dispatch(&key, custom(json!(1)));
let mut parked = dispatcher.dispatch(&key, custom(json!(2)));
assert!(first.poll_unpin(&mut cx).is_pending());
assert!(parked.poll_unpin(&mut cx).is_pending());
drop(parked);
for _ in 0..4 {
let _ = driver.poll_unpin(&mut cx);
}
assert!(first.poll_unpin(&mut cx).is_ready());
assert_eq!(
served.load(Ordering::SeqCst),
1,
"the handler never saw the dispatch dropped before it was sent"
);
}
#[test]
fn deregistering_a_serial_key_drains_its_queue_with_handler_unavailable() {
let (dispatcher, registrar, mut driver) = Bus::channel_with(ServingPolicy {
serial_per_handler: true,
..ServingPolicy::default()
});
let (blocked, open) = Echo::gated();
let key = HandlerKey::from("echo");
driver.register("echo", blocked).expect("register");
let waker = noop_waker_ref();
let mut cx = Context::from_waker(waker);
let mut a = dispatcher.dispatch(&key, custom(json!("a")));
let mut b = dispatcher.dispatch(&key, custom(json!("b")));
let mut c = dispatcher.dispatch(&key, custom(json!("c")));
for pending in [&mut a, &mut b, &mut c] {
assert!(pending.poll_unpin(&mut cx).is_pending());
}
let _ = driver.poll_unpin(&mut cx);
assert_eq!(driver.in_flight(), 1);
assert!(registrar.deregister(&key));
let _ = driver.poll_unpin(&mut cx);
for (pending, name) in [(&mut b, "b"), (&mut c, "c")] {
match pending.poll_unpin(&mut cx) {
Poll::Ready(Err(report)) => {
assert_eq!(report.kind, ErrorKind::HandlerUnavailable, "{name}");
assert!(report.message.contains("echo"), "{name}: {report:?}");
}
other => panic!("{name} should have drained, got {other:?}"),
}
}
let _ = open.send(());
let _ = driver.poll_unpin(&mut cx);
assert!(a.poll_unpin(&mut cx).is_ready());
let (echo, served) = Echo::new();
registrar.register("echo", echo).expect("register");
let mut d = dispatcher.dispatch(&key, custom(json!("d")));
assert!(d.poll_unpin(&mut cx).is_pending());
let _ = driver.poll_unpin(&mut cx);
assert!(d.poll_unpin(&mut cx).is_ready());
assert_eq!(served.load(Ordering::SeqCst), 1);
}
struct SelfCaller {
dispatcher: Dispatcher,
key: HandlerKey,
nested: AtomicBool,
}
impl SelfCaller {
fn new(dispatcher: Dispatcher, key: HandlerKey) -> Self {
Self {
dispatcher,
key,
nested: AtomicBool::new(false),
}
}
}
impl Serve for SelfCaller {
type Family = rig_core::effect::family::Dynamic;
fn descriptor(&self) -> HandlerDescriptor {
HandlerDescriptor {
key: self.key.clone(),
family: FamilyDescriptor::Custom {
kind: "test:self-caller".into(),
},
layers: Vec::new(),
}
}
async fn serve(&self, _kind: EffectKind, dispatch: Dispatch) -> rig_core::serve::Reply {
if self.nested.swap(true, Ordering::SeqCst) {
return rig_core::serve::Reply::Outcome(Ok(Outcome::Custom {
payload: json!("plain"),
}));
}
let dispatcher =
super::DispatchScope::dispatcher(&dispatch).unwrap_or_else(|| self.dispatcher.clone());
let key = self.key.clone();
{
assert_eq!(
dispatcher.parent(),
Some(dispatch.id()),
"scoped to the served dispatch"
);
let mut nested = dispatcher.dispatch(&key, custom(json!("nested")));
let first = poll_fn(|cx| Poll::Ready(nested.poll_unpin(cx))).await;
let outcome = match first {
Poll::Ready(Err(report)) => Ok(Outcome::Custom {
payload: json!({
"kind": format!("{:?}", report.kind),
"message": report.message,
}),
}),
other => Err(ErrorReport::new(
ErrorKind::Internal,
format!("the nested dispatch was not refused: {other:?}"),
)),
};
rig_core::serve::Reply::Outcome(outcome)
}
}
}
#[test]
fn a_reentrant_dispatch_to_the_in_flight_key_under_serial_serving_is_refused() {
let (dispatcher, _registrar, mut driver) = Bus::channel_with(ServingPolicy {
serial_per_handler: true,
..ServingPolicy::default()
});
let key = HandlerKey::from("self");
driver
.register("self", SelfCaller::new(dispatcher.clone(), key.clone()))
.expect("register");
let waker = noop_waker_ref();
let mut cx = Context::from_waker(waker);
let mut outer = dispatcher.dispatch(&key, custom(json!("outer")));
let mut outcome = None;
for _ in 0..8 {
if let Poll::Ready(result) = outer.poll_unpin(&mut cx) {
outcome = Some(result);
break;
}
let _ = driver.poll_unpin(&mut cx);
}
let outcome = outcome
.expect("resolved, never queued behind itself")
.expect("served");
let Outcome::Custom { payload } = outcome else {
panic!("custom outcome expected, got {outcome:?}");
};
assert_eq!(payload["kind"], json!("Request"));
assert!(
payload["message"]
.as_str()
.is_some_and(|message| message.contains("re-entrant") && message.contains("self")),
"{payload}"
);
}
#[test]
fn concurrent_serving_lets_a_handler_dispatch_to_its_own_key() {
let (dispatcher, _registrar, mut driver) = Bus::channel();
let key = HandlerKey::from("self");
driver
.register("self", SelfCaller::new(dispatcher.clone(), key.clone()))
.expect("register");
let waker = noop_waker_ref();
let mut cx = Context::from_waker(waker);
let mut outer = dispatcher.dispatch(&key, custom(json!("outer")));
let mut outcome = None;
for _ in 0..8 {
if let Poll::Ready(result) = outer.poll_unpin(&mut cx) {
outcome = Some(result);
break;
}
let _ = driver.poll_unpin(&mut cx);
}
let report = outcome
.expect("resolved")
.expect_err("the nested dispatch was accepted, not refused");
assert_eq!(report.kind, ErrorKind::Internal);
}
#[test]
fn pending_and_stream_poll_cleanly_without_any_runtime() {
let (dispatcher, _registrar, mut driver) = Bus::channel();
let (echo, _) = Echo::new();
driver.register("echo", echo).expect("register");
let waker = noop_waker_ref();
let mut cx = Context::from_waker(waker);
let mut pending = dispatcher.dispatch(&HandlerKey::from("echo"), custom(json!("manual")));
let mut outcome = None;
for _ in 0..16 {
if let Poll::Ready(result) = pending.poll_unpin(&mut cx) {
outcome = Some(result);
break;
}
let _ = driver.poll_unpin(&mut cx);
}
let outcome = outcome
.expect("resolved by manual polling")
.expect("served");
assert!(matches!(outcome, Outcome::Custom { ref payload } if *payload == json!("manual")));
}
#[tokio::test]
async fn stream_dispatch_of_a_unary_kind_is_an_invalid_dispatch() {
let (dispatcher, _registrar, mut driver) = Bus::channel();
let (echo, served) = Echo::new();
driver.register("echo", echo).expect("register");
let _task = spawn(driver);
let mut stream = dispatcher.dispatch_stream(&HandlerKey::from("echo"), custom(json!(1)));
let item = within(stream.next()).await.expect("one item");
let report = item.expect_err("invalid dispatch");
assert_eq!(report.kind, ErrorKind::Request);
assert!(
report.message.contains("invalid dispatch"),
"{}",
report.message
);
assert!(within(stream.next()).await.is_none());
assert_eq!(
served.load(Ordering::SeqCst),
0,
"never reached the handler"
);
}
#[tokio::test]
async fn streaming_completion_flows_through_the_bus_final_terminated() {
let (dispatcher, _registrar, mut driver) = Bus::channel();
let model = MockCompletionModel::from_stream_turns([vec![
MockStreamEvent::text("hel"),
MockStreamEvent::text("lo"),
MockStreamEvent::final_response_with_total_tokens(7),
]]);
driver
.register("model", ModelAdapter::new("mock", model))
.expect("register");
let _task = spawn(driver);
let stream = dispatcher.dispatch_stream(&HandlerKey::from("model"), completion_kind(true));
let items: Vec<_> = within(stream.collect()).await;
let items: Vec<Relayed> = items
.into_iter()
.map(|item| item.expect("no report"))
.collect();
assert!(matches!(items.last(), Some(Relayed::Done(_))));
let text: String = items
.iter()
.filter_map(|item| match item {
Relayed::Item(Item::Event(StreamEvent::Text { text, .. })) => Some(text.as_str()),
_ => None,
})
.collect();
assert_eq!(text, "hello");
}
#[tokio::test]
async fn a_unary_dispatch_of_a_streaming_completion_folds_to_the_response() {
let (dispatcher, _registrar, mut driver) = Bus::channel();
let model = MockCompletionModel::from_stream_turns([vec![
MockStreamEvent::text("fold"),
MockStreamEvent::text("ed"),
MockStreamEvent::final_response_with_total_tokens(3),
]]);
driver
.register("model", ModelAdapter::new("mock", model))
.expect("register");
let _task = spawn(driver);
let outcome = within(dispatcher.dispatch(&HandlerKey::from("model"), completion_kind(true)))
.await
.expect("folded");
let Outcome::Completion(response) = outcome else {
panic!("expected a completion");
};
assert_eq!(response.choice, vec![AssistantContent::text("folded")]);
assert_eq!(response.usage.total_tokens, Some(3));
}
#[tokio::test]
async fn a_unary_dispatch_of_a_unary_script_resolves_the_completion() {
let (dispatcher, _registrar, mut driver) = Bus::channel();
let model = MockCompletionModel::from_turns([MockTurn::text("whole")]);
driver
.register("model", ModelAdapter::new("mock", model))
.expect("register");
let _task = spawn(driver);
let outcome = within(dispatcher.dispatch(&HandlerKey::from("model"), completion_kind(false)))
.await
.expect("served");
assert!(
matches!(outcome, Outcome::Completion(ref r) if r.choice == vec![AssistantContent::text("whole")])
);
}
#[tokio::test]
async fn dropping_the_stream_cancels_the_handler() {
struct Chatty {
sends: Arc<AtomicUsize>,
cancelled: Arc<AtomicUsize>,
}
impl Serve for Chatty {
type Family = rig_core::effect::family::Dynamic;
fn descriptor(&self) -> HandlerDescriptor {
HandlerDescriptor {
key: HandlerKey::from("chatty"),
family: FamilyDescriptor::Completion {
model: "chatty".into(),
capabilities: Default::default(),
},
layers: Vec::new(),
}
}
async fn serve(&self, _kind: EffectKind, _dispatch: Dispatch) -> CoreReply {
struct Cancelled(Arc<AtomicUsize>);
impl Drop for Cancelled {
fn drop(&mut self) {
self.0.fetch_add(1, Ordering::SeqCst);
}
}
let sends = self.sends.clone();
let cancelled = self.cancelled.clone();
CoreReply::written(move |mut out| async move {
let _cancelled = Cancelled(cancelled);
loop {
if out.text("x").await.is_err() {
return;
}
sends.fetch_add(1, Ordering::SeqCst);
}
})
}
}
let sends = Arc::new(AtomicUsize::new(0));
let cancelled = Arc::new(AtomicUsize::new(0));
let (dispatcher, _registrar, mut driver) = Bus::channel_with(ServingPolicy {
stream_capacity: 4,
..ServingPolicy::default()
});
driver
.register(
"chatty",
Chatty {
sends: sends.clone(),
cancelled: cancelled.clone(),
},
)
.expect("register");
let _task = spawn(driver);
let mut stream = dispatcher.dispatch_stream(&HandlerKey::from("chatty"), completion_kind(true));
within(stream.next())
.await
.expect("first event")
.expect("ok");
within(stream.next())
.await
.expect("second event")
.expect("ok");
tokio::time::sleep(Duration::from_millis(50)).await;
let stalled = sends.load(Ordering::SeqCst);
assert!(
stalled <= 4 + 2,
"bounded channel stalls the handler: {stalled}"
);
tokio::time::sleep(Duration::from_millis(30)).await;
assert_eq!(
sends.load(Ordering::SeqCst),
stalled,
"no progress while paused"
);
drop(stream);
within(poll_fn(|cx| {
if cancelled.load(Ordering::SeqCst) == 1 {
Poll::Ready(())
} else {
cx.waker().wake_by_ref();
Poll::Pending
}
}))
.await;
}
#[tokio::test]
async fn tool_memory_and_fn_adapters_serve_their_families() {
let (dispatcher, _registrar, mut driver) = Bus::channel();
driver
.register("add", ToolAdapter::new(Add))
.expect("register");
driver
.register(
"memory",
MemoryAdapter::new(InMemoryConversationMemory::new()),
)
.expect("register");
driver
.register(
"shout",
ToolFn::new(
"shout",
"uppercases",
json!({"type": "object"}),
|_context: &mut ToolContext, args: serde_json::Value| {
Box::pin(async move {
Ok(ToolOutput::text(
args["text"].as_str().unwrap_or_default().to_uppercase(),
))
}) as rig_core::wasm_compat::WasmBoxedFuture<'_, _>
},
),
)
.expect("register");
let _task = spawn(driver);
let outcome = within(dispatcher.dispatch(
&HandlerKey::from("add"),
EffectKind::ToolCall {
name: "add".into(),
args: r#"{"a": 2, "b": 3}"#.into(),
},
))
.await
.expect("served");
let Outcome::ToolResult { result, .. } = outcome else {
panic!("expected a tool result");
};
assert_eq!(result.output().as_json(), Some(&json!(5)));
let outcome = within(dispatcher.dispatch(
&HandlerKey::from("shout"),
EffectKind::ToolCall {
name: "shout".into(),
args: r#"{"text": "hi"}"#.into(),
},
))
.await
.expect("served");
let Outcome::ToolResult { result, .. } = outcome else {
panic!("expected a tool result");
};
assert_eq!(result.output().as_text(), Some("HI"));
let conversation = ConversationId::from("c1");
let memory = HandlerKey::from("memory");
within(dispatcher.dispatch(
&memory,
EffectKind::Memory {
op: MemoryOp::Append {
conversation: conversation.clone(),
messages: vec![Message::user("remember me")],
},
},
))
.await
.expect("appended");
let loaded = within(dispatcher.dispatch(
&memory,
EffectKind::Memory {
op: MemoryOp::Load {
conversation: conversation.clone(),
},
},
))
.await
.expect("loaded");
assert!(matches!(
loaded,
Outcome::Memory(MemoryOutcome::Loaded { ref messages }) if messages.len() == 1
));
within(dispatcher.dispatch(
&memory,
EffectKind::Memory {
op: MemoryOp::Clear { conversation },
},
))
.await
.expect("cleared");
let report = within(dispatcher.dispatch(&HandlerKey::from("add"), custom(json!(1))))
.await
.expect_err("wrong family");
assert_eq!(report.kind, ErrorKind::HandlerUnavailable);
}
#[tokio::test]
async fn driver_completes_when_dispatchers_drop_and_in_flight_work_finishes() {
let (dispatcher, _registrar, mut driver) = Bus::channel();
let (echo, open) = Echo::gated();
driver.register("echo", echo).expect("register");
let task = spawn(driver);
let pending = dispatcher.dispatch(&HandlerKey::from("echo"), custom(json!(1)));
let mut pending = Box::pin(pending);
assert!(poll_fn(|cx| Poll::Ready(pending.poll_unpin(cx).is_pending())).await);
drop(dispatcher);
tokio::time::sleep(Duration::from_millis(20)).await;
assert!(!task.is_finished(), "in-flight work keeps the driver alive");
let _ = open.send(());
within(pending).await.expect("served after the gate");
within(task).await.expect("driver ends");
}
const _: fn() = || {
fn assert_clone_send_sync<T: Clone + Send + Sync + 'static>() {}
assert_clone_send_sync::<Dispatcher>();
};
#[test]
fn unary_dispatch_median_is_under_fifty_microseconds() {
let (dispatcher, _registrar, mut driver) = Bus::channel();
let (echo, _) = Echo::new();
driver.register("echo", echo).expect("register");
let key = HandlerKey::from("echo");
let waker = noop_waker_ref();
let mut cx = Context::from_waker(waker);
for _ in 0..100 {
let mut pending = dispatcher.dispatch(&key, custom(json!(0)));
loop {
if pending.poll_unpin(&mut cx).is_ready() {
break;
}
let _ = driver.poll_unpin(&mut cx);
}
}
let mut samples = Vec::with_capacity(10_000);
for n in 0..10_000u64 {
let started = std::time::Instant::now();
let mut pending = dispatcher.dispatch(&key, custom(json!(n)));
loop {
if pending.poll_unpin(&mut cx).is_ready() {
break;
}
let _ = driver.poll_unpin(&mut cx);
}
samples.push(started.elapsed());
}
samples.sort();
let median = samples[samples.len() / 2];
eprintln!(
"unary dispatch median: {median:?} (p90 {:?})",
samples[samples.len() * 9 / 10]
);
assert!(
median < Duration::from_micros(50),
"unary dispatch median {median:?} exceeds 50 µs"
);
}
struct Hanging {
dropped: Arc<AtomicBool>,
}
struct DropFlag(Arc<AtomicBool>);
impl Drop for DropFlag {
fn drop(&mut self) {
self.0.store(true, Ordering::SeqCst);
}
}
impl Serve for Hanging {
type Family = rig_core::effect::family::Dynamic;
fn descriptor(&self) -> HandlerDescriptor {
HandlerDescriptor {
key: HandlerKey::from("hanging"),
family: FamilyDescriptor::Custom {
kind: "test:hanging".into(),
},
layers: Vec::new(),
}
}
async fn serve(&self, _kind: EffectKind, dispatch: Dispatch) -> CoreReply {
let _flag = DropFlag(self.dropped.clone());
let _dispatch = dispatch;
std::future::pending().await
}
}
#[test]
fn dropping_a_pending_cancels_its_unary_handler() {
let (dispatcher, _registrar, mut driver) = Bus::channel();
let dropped = Arc::new(AtomicBool::new(false));
driver
.register(
"hanging",
Hanging {
dropped: dropped.clone(),
},
)
.expect("register");
let waker = noop_waker_ref();
let mut cx = Context::from_waker(waker);
let mut pending = dispatcher.dispatch(&HandlerKey::from("hanging"), custom(json!(1)));
assert!(pending.poll_unpin(&mut cx).is_pending());
let _ = driver.poll_unpin(&mut cx);
assert_eq!(driver.in_flight(), 1);
assert!(!dropped.load(Ordering::SeqCst));
drop(pending);
let _ = driver.poll_unpin(&mut cx);
assert!(
dropped.load(Ordering::SeqCst),
"dropping the Pending dropped the handler future on the driver's next poll"
);
assert_eq!(driver.in_flight(), 0);
}
#[test]
fn an_effect_stream_polls_cleanly_without_any_runtime() {
let (dispatcher, _registrar, mut driver) = Bus::channel();
let model = MockCompletionModel::from_stream_turns([vec![
MockStreamEvent::text("manual "),
MockStreamEvent::text("stream"),
MockStreamEvent::final_response_with_total_tokens(2),
]]);
driver
.register("model", ModelAdapter::new("mock", model))
.expect("register");
let waker = noop_waker_ref();
let mut cx = Context::from_waker(waker);
let mut stream = dispatcher.dispatch_stream(&HandlerKey::from("model"), completion_kind(true));
let mut items = Vec::new();
let mut ended = false;
for _ in 0..64 {
match stream.poll_next_unpin(&mut cx) {
Poll::Ready(Some(item)) => items.push(item),
Poll::Ready(None) => {
ended = true;
break;
}
Poll::Pending => {
let _ = driver.poll_unpin(&mut cx);
}
}
}
assert!(ended, "the stream ended under manual polling: {items:?}");
assert!(
matches!(items.last(), Some(Ok(Relayed::Done(_)))),
"the last item is the response: {items:?}"
);
assert!(items.iter().all(Result::is_ok), "{items:?}");
}
#[test]
fn register_refuses_a_family_change_under_a_live_key() {
let (dispatcher, registrar, mut driver) = Bus::channel();
let (echo, served) = Echo::new();
driver.register("k", echo).expect("register");
let refused = registrar
.register(
"k",
ModelAdapter::new("mock", MockCompletionModel::text("x")),
)
.expect_err("a Completion handler cannot replace a Custom one");
assert_eq!(refused.kind, ErrorKind::HandlerUnavailable);
assert!(refused.message.contains("k"), "{refused:?}");
let waker = noop_waker_ref();
let mut cx = Context::from_waker(waker);
let mut pending = dispatcher.dispatch(&HandlerKey::from("k"), custom(json!(1)));
assert!(pending.poll_unpin(&mut cx).is_pending());
let _ = driver.poll_unpin(&mut cx);
assert!(pending.poll_unpin(&mut cx).is_ready());
assert_eq!(served.load(Ordering::SeqCst), 1);
let (replacement, _) = Echo::new();
registrar.register("k", replacement).expect("same family");
}
#[test]
fn direct_registration_supersedes_an_earlier_mailbox_registration() {
let (dispatcher, registrar, mut driver) = Bus::channel();
let (earlier, earlier_served) = Echo::new();
let (latest, latest_served) = Echo::new();
registrar.register("echo", earlier).expect("queued");
driver.register("echo", latest).expect("installed");
let mut cx = Context::from_waker(noop_waker_ref());
let mut pending = dispatcher.dispatch(&HandlerKey::from("echo"), custom(json!(1)));
assert!(pending.poll_unpin(&mut cx).is_pending());
let _ = driver.poll_unpin(&mut cx);
assert!(matches!(pending.poll_unpin(&mut cx), Poll::Ready(Ok(_))));
assert_eq!(earlier_served.load(Ordering::SeqCst), 0);
assert_eq!(latest_served.load(Ordering::SeqCst), 1);
}
#[test]
fn direct_deregistration_drops_an_earlier_mailbox_registration_immediately() {
let (_dispatcher, registrar, mut driver) = Bus::channel();
let dropped = Arc::new(AtomicUsize::new(0));
registrar
.register("flag", DropCounter(dropped.clone()))
.expect("queued");
let key = HandlerKey::from("flag");
assert!(driver.deregister(&key));
assert!(registrar.descriptor(&key).is_none());
assert_eq!(dropped.load(Ordering::SeqCst), 1);
let mut cx = Context::from_waker(noop_waker_ref());
let _ = driver.poll_unpin(&mut cx);
assert!(
!driver.deregister(&key),
"removed handler cannot be resurrected"
);
}
#[tokio::test]
async fn a_dispatch_right_after_a_runtime_registration_is_served_by_the_new_handler() {
let (dispatcher, registrar, driver) = Bus::channel();
let (echo, served) = Echo::new();
registrar.register("echo", echo).expect("fresh key");
let pending = dispatcher.dispatch(&HandlerKey::from("echo"), custom(json!(1)));
let _task = spawn(driver);
within(pending).await.expect("served by the new handler");
assert_eq!(served.load(Ordering::SeqCst), 1);
}
#[tokio::test]
async fn a_typed_view_binds_synchronously_after_a_runtime_registration() {
let (dispatcher, registrar, _driver) = Bus::channel();
registrar
.register(
"model",
ModelAdapter::new("mock", MockCompletionModel::text("hi")),
)
.expect("fresh key");
let model: ModelHandle = dispatcher
.handle(&HandlerKey::from("model"))
.expect("bound from the descriptor table");
assert_eq!(model.label().as_str(), "mock");
assert_eq!(
dispatcher
.descriptor(&HandlerKey::from("model"))
.expect("published")
.family
.family(),
EffectFamily::Completion
);
let (echo, _) = Echo::new();
let report = registrar
.register("model", echo)
.expect_err("a custom handler cannot replace a completion");
assert_eq!(report.kind, ErrorKind::HandlerUnavailable);
assert_eq!(
dispatcher
.descriptor(&HandlerKey::from("model"))
.expect("still published")
.family
.family(),
EffectFamily::Completion
);
}
#[tokio::test]
async fn a_dispatch_after_a_deregistration_is_unavailable_before_the_driver_served_it() {
let (dispatcher, registrar, mut driver) = Bus::channel();
let (echo, served) = Echo::new();
driver.register("echo", echo).expect("register");
assert!(registrar.deregister(&HandlerKey::from("echo")));
assert!(dispatcher.descriptor(&HandlerKey::from("echo")).is_none());
let pending = dispatcher.dispatch(&HandlerKey::from("echo"), custom(json!(1)));
let _task = spawn(driver);
let report = within(pending).await.expect_err("deregistered");
assert_eq!(report.kind, ErrorKind::HandlerUnavailable);
assert_eq!(served.load(Ordering::SeqCst), 0);
}
struct RegistersOnDrop {
registrar: Registrar,
}
impl Serve for RegistersOnDrop {
type Family = rig_core::effect::family::Dynamic;
fn descriptor(&self) -> HandlerDescriptor {
HandlerDescriptor {
key: HandlerKey::from("echo"),
family: FamilyDescriptor::Custom {
kind: "test:echo".into(),
},
layers: Vec::new(),
}
}
async fn serve(&self, _kind: EffectKind, _dispatch: Dispatch) -> rig_core::serve::Reply {
rig_core::serve::Reply::Outcome(Ok(Outcome::Custom {
payload: json!("never"),
}))
}
}
impl Drop for RegistersOnDrop {
fn drop(&mut self) {
let (echo, _) = Echo::new();
self.registrar
.register("from-drop", echo)
.expect("a fresh key from inside a drop");
}
}
#[tokio::test]
async fn a_displaced_handler_is_dropped_outside_every_lock() {
let (dispatcher, registrar, mut driver) = Bus::channel();
driver
.register(
"echo",
RegistersOnDrop {
registrar: registrar.clone(),
},
)
.expect("register");
let (echo, served) = Echo::new();
registrar.register("echo", echo).expect("same family");
let _task = spawn(driver);
within(dispatcher.dispatch(&HandlerKey::from("echo"), custom(json!(1))))
.await
.expect("served by the replacement");
assert_eq!(served.load(Ordering::SeqCst), 1);
assert!(
dispatcher
.descriptor(&HandlerKey::from("from-drop"))
.is_some(),
"the displaced handler's drop ran and registered"
);
}
struct DropCounter(Arc<AtomicUsize>);
impl Serve for DropCounter {
type Family = rig_core::effect::family::Dynamic;
fn descriptor(&self) -> HandlerDescriptor {
HandlerDescriptor {
key: HandlerKey::from("flag"),
family: FamilyDescriptor::Custom {
kind: "test:flag".into(),
},
layers: Vec::new(),
}
}
async fn serve(&self, _kind: EffectKind, _dispatch: Dispatch) -> rig_core::serve::Reply {
rig_core::serve::Reply::Outcome(Ok(Outcome::Custom {
payload: json!(null),
}))
}
}
impl Drop for DropCounter {
fn drop(&mut self) {
self.0.fetch_add(1, Ordering::SeqCst);
}
}
#[tokio::test]
async fn a_dropped_driver_drops_the_registrations_it_never_installed() {
let (dispatcher, registrar, driver) = Bus::channel();
let dropped = Arc::new(AtomicUsize::new(0));
registrar
.register("flag", DropCounter(dropped.clone()))
.expect("fresh key");
assert_eq!(dropped.load(Ordering::SeqCst), 0);
drop(driver);
assert_eq!(
dropped.load(Ordering::SeqCst),
1,
"the handler posted and never installed went with the driver"
);
registrar
.register("late", DropCounter(dropped.clone()))
.expect("the descriptor table outlives the driver");
assert!(dispatcher.descriptor(&HandlerKey::from("late")).is_some());
assert!(registrar.is_closed());
let report = within(dispatcher.dispatch(&HandlerKey::from("late"), custom(json!(1))))
.await
.expect_err("closed");
assert_eq!(report.kind, ErrorKind::BusClosed);
}
#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
struct AskUser {
prompt: String,
}
#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
struct Reply {
text: String,
}
impl rig_core::effect::CustomEffect for AskUser {
const KIND: &'static str = "test:ask_user";
type Answer = Reply;
}
struct AskUserHandler {
misbehave: bool,
}
impl Serve for AskUserHandler {
type Family = rig_core::effect::family::Custom<AskUser>;
fn descriptor(&self) -> HandlerDescriptor {
HandlerDescriptor {
key: HandlerKey::from("ask"),
family: FamilyDescriptor::Custom {
kind: AskUser::KIND.into(),
},
layers: Vec::new(),
}
}
async fn serve(&self, kind: EffectKind, _dispatch: Dispatch) -> rig_core::serve::Reply {
let misbehave = self.misbehave;
{
let EffectKind::Custom { payload, .. } = kind else {
return rig_core::serve::Reply::Outcome(Err(ErrorReport::new(
ErrorKind::Internal,
"not custom",
)));
};
let answer = if misbehave {
json!({"nope": 1})
} else {
let ask: AskUser = serde_json::from_value(payload).expect("an AskUser");
json!({"text": format!("you asked: {}", ask.prompt)})
};
rig_core::serve::Reply::Outcome(Ok(Outcome::Custom { payload: answer }))
}
}
}
#[tokio::test]
async fn a_typed_key_binds_with_an_existence_check_and_a_handle_dispatches_its_family() {
let (dispatcher, _registrar, mut driver) = Bus::channel();
let key: Key<rig_core::effect::family::Completion> = driver
.register_typed(
"model",
ModelAdapter::new(
"mock",
MockCompletionModel::from_turns([MockTurn::text("typed"), MockTurn::text("typed")]),
),
)
.expect("a completion adapter proves a completion key");
assert_eq!(key.as_str(), "model");
assert_eq!(format!("{key}"), "model");
assert_eq!(
serde_json::to_value(&key).expect("serializes"),
json!("model"),
"on the wire a typed key is the bare string"
);
let back: Key<rig_core::effect::family::Completion> =
serde_json::from_value(json!("model")).expect("deserializes");
assert_eq!(back, key);
let _task = spawn(driver);
let model = dispatcher.bind(&key).expect("bound by existence");
let response = within(model.dispatch(completion_request_value()))
.await
.expect("the family's own answer");
assert_eq!(response.choice, vec![AssistantContent::text("typed")]);
let response = within(model.call(completion_request_value()))
.await
.expect("the convenience is the same dispatch");
assert_eq!(response.choice, vec![AssistantContent::text("typed")]);
let lie: Key<rig_core::effect::family::Tool> = Key::new_unchecked(HandlerKey::from("model"));
let report = dispatcher
.bind(&lie)
.expect_err("a completion is not a tool");
assert_eq!(report.kind, ErrorKind::HandlerUnavailable);
}
#[tokio::test]
async fn register_typed_refuses_a_handler_of_another_family() {
let (_dispatcher, registrar, _driver) = Bus::channel();
let report = registrar
.register_typed::<rig_core::effect::family::Tool>(
"model",
ModelAdapter::new("mock", MockCompletionModel::text("x")),
)
.expect_err("a completion adapter cannot prove a tool key");
assert_eq!(report.kind, ErrorKind::HandlerUnavailable);
assert!(
report.message.contains("Key<tool_call>") && report.message.contains("completion"),
"{}",
report.message
);
assert!(
registrar.descriptor(&HandlerKey::from("model")).is_none(),
"nothing was published"
);
}
#[tokio::test]
async fn a_custom_effect_round_trips_through_a_typed_handle() {
let (dispatcher, registrar, driver) = Bus::channel();
let key = registrar
.register_typed::<rig_core::effect::family::Custom<AskUser>>(
"ask",
AskUserHandler { misbehave: false },
)
.expect("a custom handler proves its kind");
registrar
.register("ask-badly", AskUserHandler { misbehave: true })
.expect("fresh key");
let _task = spawn(driver);
let ask = dispatcher.bind(&key).expect("bound");
let reply = within(ask.dispatch(AskUser {
prompt: "name?".into(),
}))
.await
.expect("the declared answer");
assert_eq!(
reply,
Reply {
text: "you asked: name?".into()
}
);
let ask = dispatcher
.custom::<AskUser>(&HandlerKey::from("ask-badly"))
.expect("the kind matches");
let report = within(ask.dispatch(AskUser { prompt: "?".into() }))
.await
.expect_err("not a Reply");
assert_eq!(report.kind, ErrorKind::Internal);
assert!(report.message.contains(AskUser::KIND), "{}", report.message);
#[derive(serde::Serialize, serde::Deserialize)]
struct Other;
impl rig_core::effect::CustomEffect for Other {
const KIND: &'static str = "test:other";
type Answer = ();
}
let report = dispatcher
.custom::<Other>(&HandlerKey::from("ask"))
.expect_err("another kind");
assert_eq!(report.kind, ErrorKind::HandlerUnavailable);
assert!(report.message.contains("test:other"), "{}", report.message);
}
fn completion_request_value() -> rig_core::completion::CompletionRequest {
match completion_kind(false) {
EffectKind::Completion { request, .. } => request,
other => panic!("a completion kind, got {}", other.name()),
}
}
#[test]
fn a_command_offered_after_the_close_is_refused_under_the_queue_lock() {
let (dispatcher, _registrar, driver) = Bus::channel();
let shared = Arc::clone(&dispatcher.shared);
drop(driver);
let cx = std::task::Context::from_waker(noop_waker_ref());
let (reply, _receiver) = oneshot::channel();
let (_guard, cancel) = oneshot::channel();
let offered = shared.enqueue(
super::dispatcher::Command {
lineage: super::dispatcher::Lineage::new(rig_core::effect::EffectId::from_raw(9), None),
id: rig_core::effect::EffectId::from_raw(9),
key: HandlerKey::from("echo"),
kind: custom(json!(1)),
parent: None,
scope: None,
context: None,
adapter_context: None,
published: None,
reply: super::dispatcher::Reply::Unary(reply),
span: tracing::Span::none(),
cancel,
},
&Arc::new(futures::task::AtomicWaker::new()),
&cx,
);
assert!(matches!(offered, super::dispatcher::Enqueue::Closed));
assert_eq!(shared.buffered(), 0, "nothing is buffered after the close");
}
#[tokio::test]
async fn a_registration_posted_just_before_a_dispatch_serves_it_whichever_poll_each_lands_in() {
let (dispatcher, registrar, driver) = Bus::channel();
let _task = spawn(driver);
for round in 0..50 {
let key = HandlerKey::from(format!("late-{round}"));
let (echo, served) = Echo::new();
registrar.register(key.clone(), echo).expect("fresh key");
within(dispatcher.dispatch(&key, custom(json!(round))))
.await
.expect("served by the handler registered just before it");
assert_eq!(served.load(Ordering::SeqCst), 1);
}
}
#[tokio::test]
async fn a_stream_written_through_the_writer_is_well_formed() {
struct Writes;
impl Serve for Writes {
type Family = rig_core::effect::family::Dynamic;
fn descriptor(&self) -> HandlerDescriptor {
HandlerDescriptor {
key: HandlerKey::from("writer"),
family: FamilyDescriptor::Completion {
model: "writer".into(),
capabilities: Default::default(),
},
layers: Vec::new(),
}
}
async fn serve(&self, _kind: EffectKind, _dispatch: Dispatch) -> CoreReply {
CoreReply::written(|mut out| async move {
let _ = out.reasoning("thinking").await;
let _ = out.text("hel").await;
let _ = out.text("lo").await;
let _ = out.tool_call("add", json!({"x": 1})).await;
let _ = out.text("after").await;
let _ = out
.finish(
"writer",
rig_core::operation::Finish {
usage: rig_core::completion::Usage::default(),
..rig_core::operation::Finish::default()
},
)
.await;
})
}
}
let (dispatcher, _registrar, mut driver) = Bus::channel();
driver.register("writer", Writes).expect("register");
let _task = spawn(driver);
let mut stream = dispatcher.dispatch_stream(&HandlerKey::from("writer"), completion_kind(true));
let mut items = Vec::new();
while let Some(item) = within(stream.next()).await {
items.push(item);
}
let mut items: Vec<Relayed> = items
.into_iter()
.map(|item| item.expect("a clean stream"))
.collect();
let Some(Relayed::Done(response)) = items.pop() else {
panic!("the stream ends with the response: {items:?}");
};
let transcript = rig_core::streaming::Transcript::parse(
serde_json::to_value(
items
.into_iter()
.map(|item| match item {
Relayed::Item(item) => item,
Relayed::Done(_) => panic!("one response, last"),
})
.collect::<Vec<_>>(),
)
.expect("items serialize"),
)
.expect("the writer's items are in order and every part ends");
let starts = transcript
.events()
.filter(|event| matches!(event, StreamEvent::Start { .. }))
.count();
assert_eq!(starts, 4, "reasoning, text, tool call, text");
assert_eq!(
response.choice.len(),
4,
"reasoning, text, tool call, text as content: {:?}",
response.choice
);
}
#[derive(Clone)]
struct ProbeRerank {
max_documents: usize,
failure: Option<&'static str>,
}
impl ProbeRerank {
fn model(self) -> rig_core::Model<rig_core::driver::Local<rig_core::operation::Rerank>, Self> {
rig_core::Model::new(
rig_core::driver::Local::new("probe")
.with_capabilities(rig_core::wire::Capabilities::rerank(self.max_documents)),
self,
)
}
}
impl rig_core::driver::Transport<rig_core::driver::Local<rig_core::operation::Rerank>>
for ProbeRerank
{
fn send(
&self,
request: rig_core::operation::RerankRequest,
_exchange: rig_core::driver::Exchange,
) -> rig_core::driver::Opening<rig_core::driver::Step<rig_core::operation::Rerank>> {
let failure = self.failure;
rig_core::driver::Opening::ready(match failure {
Some(message) => {
rig_core::driver::Opened::failed(ProviderError::Response(message.to_owned()))
}
None => rig_core::driver::Opened::new(futures::stream::iter([Ok(
rig_core::driver::Step::End(RerankResponse {
provider: "probe".into(),
..RerankResponse::new(
request
.documents
.into_iter()
.enumerate()
.map(|(index, document)| RerankResult {
index,
document: Some(document),
relevance_score: 1.0,
})
.collect(),
)
}),
)])),
})
}
}
#[tokio::test]
async fn a_rerank_adapter_serves_every_handle_clone_and_publishes_its_batch_size() {
let (dispatcher, _registrar, mut driver) = Bus::channel();
let probe = ProbeRerank {
max_documents: 7,
failure: None,
};
driver
.register("rerank:probe", ModelAdapter::new("probe", probe.model()))
.expect("register");
let task = spawn(driver);
let handle: super::RerankHandle = dispatcher
.handle(&HandlerKey::from("rerank:probe"))
.expect("a rerank handler");
for _ in 0..3 {
let response = within(handle.rerank("q", vec!["a".to_owned(), "b".to_owned()]))
.await
.expect("rerank");
assert_eq!(response.results.len(), 2);
assert_eq!(response.provider, "probe");
let via_clone = within(handle.clone().rerank("q", vec!["c".to_owned()]))
.await
.expect("rerank via clone");
assert_eq!(via_clone.results[0].document.as_deref(), Some("c"));
}
assert_eq!(handle.max_documents(), Some(7));
assert_eq!(handle.label(), "probe");
assert_eq!(
handle.descriptor().family,
FamilyDescriptor::Rerank {
model: "probe".to_owned(),
max_documents: 7,
}
);
drop((handle, dispatcher));
within(task).await.expect("driver task");
}
#[tokio::test]
async fn a_rerank_model_error_crosses_the_bus_as_a_report() {
let (dispatcher, _registrar, mut driver) = Bus::channel();
let failing = ProbeRerank {
max_documents: 1,
failure: Some("probe"),
};
driver
.register("rerank:once", ModelAdapter::new("once", failing.model()))
.expect("register");
let task = spawn(driver);
let handle: super::RerankHandle = dispatcher
.handle(&HandlerKey::from("rerank:once"))
.expect("a rerank handler");
let report = within(handle.rerank("q", vec![]))
.await
.expect_err("the model fails");
assert_eq!(report.kind, ErrorKind::Response);
assert!(report.message.contains("probe"), "{}", report.message);
drop((handle, dispatcher));
within(task).await.expect("driver task");
}
#[derive(Clone, Default)]
struct Counting {
begun: Arc<AtomicUsize>,
resolved: Arc<AtomicUsize>,
discarded: Arc<AtomicUsize>,
observation: Option<rig_core::observe::AdapterContext>,
observation_sink: Option<Arc<rig_core::observe::ObservationLog>>,
contexts: Arc<
Mutex<
std::collections::BTreeMap<
rig_core::effect::EffectId,
rig_core::observe::AdapterContext,
>,
>,
>,
}
impl rig_core::serve::Recorder for Counting {
fn adapter_context(
&self,
id: rig_core::effect::EffectId,
) -> Option<rig_core::observe::AdapterContext> {
self.contexts
.lock()
.unwrap()
.get(&id)
.cloned()
.or_else(|| self.observation.clone())
}
fn tool_output(&self, _: rig_core::effect::EffectId, _: rig_core::tool::ToolResultContext) {}
fn handlers(&self, _handlers: Vec<HandlerDescriptor>) {}
fn begin(
&self,
id: rig_core::effect::EffectId,
key: HandlerKey,
kind: EffectKind,
origin: rig_core::serve::Origin,
) {
self.begun.fetch_add(1, Ordering::SeqCst);
if let Some(sink) = &self.observation_sink {
let subject = rig_core::observe::Subject {
scope: origin.scope.map(|scope| scope.to_string()),
effect: Some(id),
parent: origin.parent,
key: Some(key),
family: Some(kind.family()),
..Default::default()
};
self.contexts.lock().unwrap().insert(
id,
rig_core::observe::AdapterContext::new(
sink.clone(),
subject,
format!("dispatch/{id:?}"),
),
);
}
}
fn discard(&self, _id: rig_core::effect::EffectId) {
self.discarded.fetch_add(1, Ordering::SeqCst);
}
fn patch(&self, _id: rig_core::effect::EffectId, _kind: EffectKind) {}
fn keep_events(&self) -> bool {
false
}
fn event(&self, _id: rig_core::effect::EffectId, _event: &Item<StreamEvent>) {}
fn resolve(&self, _id: rig_core::effect::EffectId, _outcome: Result<Outcome, ErrorReport>) {
self.resolved.fetch_add(1, Ordering::SeqCst);
}
}
#[test]
fn a_pending_dropped_before_the_driver_polls_never_reaches_its_handler() {
let (dispatcher, _registrar, mut driver) = Bus::channel();
let (echo, served) = Echo::new();
driver.register("echo", echo).expect("register");
let recorder = Counting::default();
driver.record_to(recorder.clone());
let waker = noop_waker_ref();
let mut cx = Context::from_waker(waker);
let mut pending = dispatcher.dispatch(&HandlerKey::from("echo"), custom(json!(1)));
assert!(pending.poll_unpin(&mut cx).is_pending());
assert_eq!(dispatcher.buffered(), 1, "sent, not yet taken");
drop(pending);
for _ in 0..4 {
let _ = driver.poll_unpin(&mut cx);
}
assert_eq!(served.load(Ordering::SeqCst), 0, "the handler was polled");
assert_eq!(
recorder.begun.load(Ordering::SeqCst),
0,
"a record was opened"
);
assert_eq!(driver.in_flight(), 0);
assert_eq!(dispatcher.buffered(), 0);
let mut stream = dispatcher.dispatch_stream(&HandlerKey::from("echo"), completion_kind(true));
assert!(stream.poll_next_unpin(&mut cx).is_pending());
assert_eq!(dispatcher.buffered(), 1);
drop(stream);
for _ in 0..4 {
let _ = driver.poll_unpin(&mut cx);
}
assert_eq!(served.load(Ordering::SeqCst), 0);
assert_eq!(recorder.begun.load(Ordering::SeqCst), 0);
assert_eq!(driver.in_flight(), 0);
let mut live = dispatcher.dispatch(&HandlerKey::from("echo"), custom(json!(2)));
assert!(live.poll_unpin(&mut cx).is_pending());
for _ in 0..4 {
let _ = driver.poll_unpin(&mut cx);
}
assert!(live.poll_unpin(&mut cx).is_ready());
assert_eq!(served.load(Ordering::SeqCst), 1);
assert_eq!(recorder.begun.load(Ordering::SeqCst), 1);
assert_eq!(recorder.resolved.load(Ordering::SeqCst), 1);
}
#[tokio::test]
async fn concurrent_agent_wrappers_receive_distinct_recorder_contexts() {
for streamed in [false, true] {
let model = if streamed {
MockCompletionModel::from_stream_turns((0..2).map(|_| {
vec![
MockStreamEvent::text("ok"),
MockStreamEvent::final_response_with_total_tokens(1),
]
}))
} else {
MockCompletionModel::from_turns((0..2).map(|_| MockTurn::text("ok")))
};
let (dispatcher, registrar, mut driver) = Bus::channel();
driver
.register("model", ModelAdapter::new("mock", model.clone()))
.unwrap();
let recorder = Counting {
observation_sink: Some(Arc::new(rig_core::observe::ObservationLog::default())),
..Counting::default()
};
driver.record_to(recorder.clone());
let task = tokio::spawn(driver);
let a = crate::agent::AgentBuilder::over_bus(
dispatcher.clone(),
registrar.clone(),
"a",
HandlerKey::from("model"),
)
.build();
let b = crate::agent::AgentBuilder::over_bus(
dispatcher,
registrar,
"b",
HandlerKey::from("model"),
)
.build();
let run = |agent: crate::agent::Agent| async move {
if streamed {
let mut stream = agent.prompt("same prompt").stream();
let mut finished = false;
while let Some(event) = within(stream.next()).await {
if let crate::agent::MultiTurnStreamItem::FinalResponse(response) =
event.unwrap()
{
assert_eq!(response.output(), "ok");
finished = true;
}
}
assert!(finished);
} else {
assert_eq!(
within(agent.prompt("same prompt").run())
.await
.unwrap()
.output,
"ok"
);
}
};
tokio::join!(run(a), run(b));
let requests = model.requests();
assert_eq!(requests.len(), 2);
let actual: std::collections::BTreeSet<_> = model
.contexts()
.iter()
.map(|context| context.as_ref().unwrap().operation().to_owned())
.collect();
assert_eq!(
actual.len(),
2,
"identical concurrent calls remain distinct"
);
let contexts = recorder.contexts.lock().unwrap();
let expected: std::collections::BTreeSet<_> = contexts
.values()
.map(|context| context.operation().to_owned())
.collect();
assert_eq!(actual, expected);
task.abort();
}
}
#[tokio::test]
async fn recorder_context_reaches_model_handles_without_overwriting_callers() {
use rig_core::observe::{AdapterContext, ObservationLog, Subject};
for streamed in [false, true] {
for explicit in [false, true] {
let model = if streamed {
MockCompletionModel::from_stream_turns([vec![
MockStreamEvent::text("ok"),
MockStreamEvent::final_response_with_total_tokens(1),
]])
} else {
MockCompletionModel::text("ok")
};
let (dispatcher, _registrar, mut driver) = Bus::channel();
driver
.register("model", ModelAdapter::new("mock", model.clone()))
.unwrap();
let sink = Arc::new(ObservationLog::default());
let recorder = Counting {
observation: Some(AdapterContext::new(
sink.clone(),
Subject::scoped("host"),
"recorder",
)),
..Counting::default()
};
driver.record_to(recorder.clone());
let task = tokio::spawn(driver);
let handle: ModelHandle = dispatcher.handle(&HandlerKey::from("model")).unwrap();
let request = completion_request_value();
let context =
explicit.then(|| AdapterContext::new(sink, Subject::scoped("caller"), "caller"));
if streamed {
let mut stream = match context {
Some(context) => handle.stream_observed(request, context),
None => handle.stream(request),
};
while let Some(event) = within(stream.next()).await {
event.unwrap();
}
} else {
let completion = match context {
Some(context) => handle.call_observed(request, context),
None => handle.call(request),
};
within(completion).await.unwrap();
}
let requests = model.requests();
assert_eq!(requests.len(), 1);
assert_eq!(
model.contexts()[0].as_ref().unwrap().operation(),
if explicit { "caller" } else { "recorder" }
);
assert_eq!(recorder.begun.load(Ordering::SeqCst), 1);
assert_eq!(recorder.resolved.load(Ordering::SeqCst), 1);
task.abort();
}
}
}
#[test]
fn a_serial_key_is_not_occupied_by_a_dispatch_cancelled_before_it_was_served() {
let (dispatcher, _registrar, mut driver) = Bus::channel_with(ServingPolicy {
serial_per_handler: true,
..ServingPolicy::default()
});
let (echo, served) = Echo::new();
driver.register("echo", echo).expect("register");
let waker = noop_waker_ref();
let mut cx = Context::from_waker(waker);
let key = HandlerKey::from("echo");
let mut cancelled = dispatcher.dispatch(&key, custom(json!(1)));
let mut kept = dispatcher.dispatch(&key, custom(json!(2)));
assert!(cancelled.poll_unpin(&mut cx).is_pending());
assert!(kept.poll_unpin(&mut cx).is_pending());
drop(cancelled);
for _ in 0..4 {
let _ = driver.poll_unpin(&mut cx);
}
assert!(
kept.poll_unpin(&mut cx).is_ready(),
"the cancelled dispatch left the key busy"
);
assert_eq!(served.load(Ordering::SeqCst), 1);
}
fn probe(pending: &mut Pending) -> Option<Result<Outcome, ErrorReport>> {
let mut cx = Context::from_waker(noop_waker_ref());
match pending.poll_unpin(&mut cx) {
Poll::Ready(outcome) => Some(outcome),
Poll::Pending => None,
}
}
fn probe_item(stream: &mut EffectStream) -> Option<Option<Result<Relayed, ErrorReport>>> {
let mut cx = Context::from_waker(noop_waker_ref());
match stream.poll_next_unpin(&mut cx) {
Poll::Ready(item) => Some(item),
Poll::Pending => None,
}
}
#[test]
fn a_probe_resolves_a_dispatch_without_an_executor() {
let (dispatcher, _registrar, mut driver) = Bus::channel();
let (echo, served) = Echo::new();
driver.register("echo", echo).expect("register");
let waker = noop_waker_ref();
let mut cx = Context::from_waker(waker);
let mut pending = dispatcher.dispatch(&HandlerKey::from("echo"), custom(json!(7)));
assert!(probe(&mut pending).is_none(), "the first probe sends");
assert_eq!(dispatcher.buffered(), 1);
let _ = driver.poll_unpin(&mut cx);
let outcome = probe(&mut pending).expect("served").expect("ok");
assert!(matches!(outcome, Outcome::Custom { ref payload } if *payload == json!(7)));
assert_eq!(served.load(Ordering::SeqCst), 1);
let mut stream = dispatcher.dispatch_stream(&HandlerKey::from("model"), completion_kind(true));
assert!(probe_item(&mut stream).is_none());
let _ = driver.poll_unpin(&mut cx);
let first = probe_item(&mut stream).expect("ready").expect("an item");
assert_eq!(
first.expect_err("unavailable").kind,
ErrorKind::HandlerUnavailable
);
assert!(
probe_item(&mut stream).expect("ready").is_none(),
"then the end"
);
}
#[test]
fn ten_thousand_probes_on_a_full_bus_keep_one_waker() {
let (dispatcher, _registrar, mut driver) = Bus::channel_with(ServingPolicy {
command_capacity: 1,
..ServingPolicy::default()
});
let (echo, served) = Echo::new();
driver.register("echo", echo).expect("register");
let key = HandlerKey::from("echo");
let mut first = dispatcher.dispatch(&key, custom(json!(1)));
let mut parked = dispatcher.dispatch(&key, custom(json!(2)));
assert!(probe(&mut first).is_none());
for _ in 0..10_000 {
assert!(probe(&mut parked).is_none());
let waker = futures::task::waker(Arc::new(CountingWake));
let mut cx = Context::from_waker(&waker);
assert!(parked.poll_unpin(&mut cx).is_pending());
}
assert_eq!(dispatcher.shared.parked_senders(), 1);
let waker = noop_waker_ref();
let mut cx = Context::from_waker(waker);
for _ in 0..4 {
let _ = driver.poll_unpin(&mut cx);
}
assert!(probe(&mut first).is_some());
assert!(probe(&mut parked).is_none(), "sent on this probe");
assert_eq!(dispatcher.buffered(), 1);
for _ in 0..4 {
let _ = driver.poll_unpin(&mut cx);
}
assert!(probe(&mut parked).is_some(), "served");
assert_eq!(served.load(Ordering::SeqCst), 2);
assert_eq!(dispatcher.shared.parked_senders(), 0);
}
struct CountingWake;
impl futures::task::ArcWake for CountingWake {
fn wake_by_ref(_arc_self: &Arc<Self>) {}
}
#[test]
fn a_parked_value_dropped_before_the_drain_leaves_no_slot_to_wake() {
let (dispatcher, _registrar, mut driver) = Bus::channel_with(ServingPolicy {
command_capacity: 1,
..ServingPolicy::default()
});
let (echo, _served) = Echo::new();
driver.register("echo", echo).expect("register");
let key = HandlerKey::from("echo");
let mut first = dispatcher.dispatch(&key, custom(json!(1)));
let mut parked = dispatcher.dispatch(&key, custom(json!(2)));
assert!(probe(&mut first).is_none());
assert!(probe(&mut parked).is_none());
assert_eq!(dispatcher.shared.parked_senders(), 1);
drop(parked);
let waker = noop_waker_ref();
let mut cx = Context::from_waker(waker);
let _ = driver.poll_unpin(&mut cx);
assert_eq!(
dispatcher.shared.parked_senders(),
0,
"the dead slot was dropped by the drain"
);
}
struct Detaching {
mailbox: Arc<Mutex<Vec<rig_core::serve::Resolver>>>,
}
impl Serve for Detaching {
type Family = rig_core::effect::family::Dynamic;
fn descriptor(&self) -> HandlerDescriptor {
HandlerDescriptor {
key: HandlerKey::from("world"),
family: FamilyDescriptor::Custom {
kind: "test:world".into(),
},
layers: Vec::new(),
}
}
async fn serve(&self, _kind: EffectKind, _dispatch: Dispatch) -> CoreReply {
let (resolver, answer) = rig_core::serve::deferred();
self.mailbox.lock().expect("mailbox").push(resolver);
CoreReply::Outcome(answer.await)
}
}
#[test]
fn a_deferred_answer_keeps_its_serial_slot_until_answered() {
let (dispatcher, _registrar, mut driver) = Bus::channel_with(ServingPolicy {
serial_per_handler: true,
..ServingPolicy::default()
});
let mailbox = Arc::new(Mutex::new(Vec::new()));
driver
.register(
"world",
Detaching {
mailbox: mailbox.clone(),
},
)
.expect("register");
let key = HandlerKey::from("world");
let mut first = dispatcher.dispatch(&key, custom(json!(1)));
let mut second = dispatcher.dispatch(&key, custom(json!(2)));
assert!(probe(&mut first).is_none());
assert!(probe(&mut second).is_none());
let waker = noop_waker_ref();
let mut cx = Context::from_waker(waker);
for _ in 0..4 {
let _ = driver.poll_unpin(&mut cx);
}
assert_eq!(mailbox.lock().expect("mailbox").len(), 1);
assert_eq!(driver.in_flight(), 1, "the pending answer occupies its key");
assert!(probe(&mut second).is_none());
let sink = mailbox.lock().expect("mailbox").remove(0);
assert!(!sink.is_closed());
let resolving = sink.resolve(Ok(Outcome::Custom {
payload: json!("answered"),
}));
assert!(resolving.is_ok());
let _ = driver.poll_unpin(&mut cx);
let outcome = probe(&mut first).expect("answered").expect("ok");
assert!(matches!(outcome, Outcome::Custom { payload: ref v } if *v == json!("answered")));
for _ in 0..4 {
let _ = driver.poll_unpin(&mut cx);
}
assert_eq!(mailbox.lock().expect("mailbox").len(), 1);
assert_eq!(driver.in_flight(), 1);
let sink = mailbox.lock().expect("mailbox").remove(0);
let resolving = sink.resolve(Ok(Outcome::Custom {
payload: json!("second"),
}));
assert!(resolving.is_ok());
let _ = driver.poll_unpin(&mut cx);
assert!(probe(&mut second).is_some());
for _ in 0..4 {
let _ = driver.poll_unpin(&mut cx);
}
assert_eq!(driver.in_flight(), 0);
}
#[test]
fn dropping_the_pending_closes_a_deferred_resolver() {
let (dispatcher, _registrar, mut driver) = Bus::channel();
let mailbox = Arc::new(Mutex::new(Vec::new()));
driver
.register(
"world",
Detaching {
mailbox: mailbox.clone(),
},
)
.expect("register");
let mut pending = dispatcher.dispatch(&HandlerKey::from("world"), custom(json!(1)));
assert!(probe(&mut pending).is_none());
let waker = noop_waker_ref();
let mut cx = Context::from_waker(waker);
let _ = driver.poll_unpin(&mut cx);
assert_eq!(mailbox.lock().expect("mailbox").len(), 1);
assert!(!mailbox.lock().expect("mailbox")[0].is_closed());
drop(pending);
let _ = driver.poll_unpin(&mut cx);
assert!(mailbox.lock().expect("mailbox")[0].is_closed());
assert_eq!(driver.in_flight(), 0);
mailbox.lock().expect("mailbox").clear();
let _ = driver.poll_unpin(&mut cx);
assert_eq!(driver.in_flight(), 0);
}
#[test]
fn descriptors_is_one_snapshot_and_a_bus_id_tells_buses_apart() {
let (dispatcher, registrar, mut driver) = Bus::channel();
let (echo, _) = Echo::new();
driver.register("echo", echo).expect("register");
driver
.register("add", ToolAdapter::new(Add))
.expect("register");
let snapshot = dispatcher.descriptors();
assert_eq!(
snapshot.iter().map(|d| d.key.as_str()).collect::<Vec<_>>(),
["add", "echo"],
"key order, one lock"
);
assert_eq!(snapshot[0].family.family(), EffectFamily::Tool);
let (echo, _) = Echo::new();
registrar.register("echo2", echo).expect("register");
assert_eq!(snapshot.len(), 2);
assert_eq!(dispatcher.descriptors().len(), 3);
let (other, _r, _d) = Bus::channel();
assert_ne!(dispatcher.id(), other.id(), "two buses, two ids");
assert_eq!(dispatcher.id(), dispatcher.clone().id(), "one bus, one id");
assert_eq!(dispatcher.id(), registrar_bus_id(®istrar, &dispatcher));
assert_ne!(dispatcher.id().as_u64(), 0);
assert!(dispatcher.id().to_string().starts_with("bus#"));
}
fn registrar_bus_id(_registrar: &Registrar, dispatcher: &Dispatcher) -> super::BusId {
dispatcher.id()
}
#[test]
fn a_pending_whose_dispatcher_died_before_its_first_poll_is_bus_closed_while_a_stream_is_in_flight()
{
let (dispatcher, _registrar, mut driver) = Bus::channel();
let (echo, _open_never) = Echo::gated();
driver.register("echo", echo).expect("register");
let waker = noop_waker_ref();
let mut cx = Context::from_waker(waker);
let mut held = dispatcher.dispatch(&HandlerKey::from("echo"), custom(json!(1)));
assert!(probe(&mut held).is_none());
let _ = driver.poll_unpin(&mut cx);
assert_eq!(driver.in_flight(), 1);
let mut late = dispatcher.dispatch(&HandlerKey::from("echo"), custom(json!(2)));
drop(dispatcher);
let _ = driver.poll_unpin(&mut cx);
assert!(
driver.poll_unpin(&mut cx).is_pending(),
"the held dispatch keeps the driver alive"
);
let report = probe(&mut late).expect("decided now").expect_err("closed");
assert_eq!(report.kind, ErrorKind::BusClosed);
assert!(probe(&mut held).is_none(), "the in-flight one is untouched");
}
#[test]
fn a_bind_on_a_closed_bus_is_bus_closed_not_unavailable() {
let (dispatcher, _registrar, mut driver) = Bus::channel();
driver
.register(
"model",
ModelAdapter::new(
"gpt",
MockCompletionModel::from_turns([MockTurn::text("hi")]),
),
)
.expect("register");
assert!(
dispatcher
.handle::<rig_core::effect::family::Completion>(&HandlerKey::from("model"))
.is_ok()
);
drop(driver);
let report = dispatcher
.handle::<rig_core::effect::family::Completion>(&HandlerKey::from("model"))
.expect_err("closed");
assert_eq!(report.kind, ErrorKind::BusClosed, "{report:?}");
}
struct Parent {
key: HandlerKey,
child: HandlerKey,
from_another_thread: bool,
held: Option<Arc<Mutex<Vec<super::Pending>>>>,
await_child: bool,
}
impl Serve for Parent {
type Family = rig_core::effect::family::Dynamic;
fn descriptor(&self) -> HandlerDescriptor {
HandlerDescriptor {
key: self.key.clone(),
family: FamilyDescriptor::Custom {
kind: "test:parent".into(),
},
layers: Vec::new(),
}
}
async fn serve(&self, _kind: EffectKind, dispatch: Dispatch) -> rig_core::serve::Reply {
let dispatcher =
super::DispatchScope::dispatcher(&dispatch).expect("served by a bus driver");
assert_eq!(dispatcher.parent(), Some(dispatch.id()));
let child = self.child.clone();
let first_poll = move |dispatcher: Dispatcher| {
let mut nested = dispatcher.dispatch(&child, custom(json!("nested")));
let mut cx = Context::from_waker(noop_waker_ref());
let first = nested.poll_unpin(&mut cx);
(first, nested)
};
let (first, nested) = if self.from_another_thread {
std::thread::spawn(move || first_poll(dispatcher))
.join()
.expect("the nested thread")
} else {
first_poll(dispatcher)
};
if let Some(held) = &self.held {
held.lock().expect("held").push(nested);
return std::future::pending().await;
}
if self.await_child {
let outcome = match first {
Poll::Ready(result) => result,
Poll::Pending => nested.await,
};
let outcome = match outcome {
Ok(outcome) => Ok(outcome),
Err(report) => Ok(Outcome::Custom {
payload: json!({
"kind": format!("{:?}", report.kind),
"message": report.message,
}),
}),
};
return rig_core::serve::Reply::Outcome(outcome);
}
let outcome = match first {
Poll::Ready(Err(report)) => Ok(Outcome::Custom {
payload: json!({
"kind": format!("{:?}", report.kind),
"message": report.message,
}),
}),
Poll::Ready(Ok(outcome)) => Ok(outcome),
Poll::Pending => Ok(Outcome::Custom {
payload: json!("accepted"),
}),
};
rig_core::serve::Reply::Outcome(outcome)
}
}
fn drive_to_outcome(
driver: &mut BusDriver,
pending: &mut super::Pending,
) -> Option<Result<Outcome, ErrorReport>> {
let mut cx = Context::from_waker(noop_waker_ref());
for _ in 0..16 {
if let Poll::Ready(result) = pending.poll_unpin(&mut cx) {
return Some(result);
}
let _ = driver.poll_unpin(&mut cx);
}
None
}
#[test]
fn a_dispatch_made_through_dispatch_context_carries_its_parent() {
let (dispatcher, _registrar, mut driver) = Bus::channel();
let (echo, served) = Echo::new();
driver.register("echo", echo).expect("register");
let held = Arc::new(Mutex::new(Vec::new()));
driver
.register(
"parent",
Parent {
key: HandlerKey::from("parent"),
child: HandlerKey::from("echo"),
from_another_thread: false,
held: Some(held.clone()),
await_child: false,
},
)
.expect("register");
let mut cx = Context::from_waker(noop_waker_ref());
let mut outer = dispatcher.dispatch(&HandlerKey::from("parent"), custom(json!("outer")));
assert_eq!(outer.parent(), None, "a consumer's dispatch has no parent");
assert!(outer.poll_unpin(&mut cx).is_pending());
let _ = driver.poll_unpin(&mut cx);
let mut child = held
.lock()
.expect("held")
.pop()
.expect("the child was parked");
assert_eq!(
child.parent(),
Some(outer.id()),
"the nested dispatch names the dispatch it was made from"
);
let outcome = drive_to_outcome(&mut driver, &mut child)
.expect("resolved")
.expect("served");
assert!(
matches!(&outcome, Outcome::Custom { payload } if *payload == json!("nested")),
"{outcome:?}"
);
assert_eq!(served.load(Ordering::SeqCst), 1);
assert_eq!(driver.in_flight(), 1, "the parent");
drop(outer);
let _ = driver.poll_unpin(&mut cx);
assert_eq!(driver.in_flight(), 0);
let stream = dispatcher.dispatch_stream(&HandlerKey::from("echo"), custom(json!(1)));
assert_eq!(stream.parent(), None);
}
#[test]
fn a_nested_serial_dispatch_from_another_thread_is_refused_by_its_chain() {
let (dispatcher, _registrar, mut driver) = Bus::channel_with(ServingPolicy {
serial_per_handler: true,
..ServingPolicy::default()
});
driver
.register(
"parent",
Parent {
key: HandlerKey::from("parent"),
child: HandlerKey::from("parent"),
from_another_thread: true,
held: None,
await_child: false,
},
)
.expect("register");
let mut outer = dispatcher.dispatch(&HandlerKey::from("parent"), custom(json!("outer")));
let outcome = drive_to_outcome(&mut driver, &mut outer)
.expect("resolved, never hung")
.expect("served");
let Outcome::Custom { payload } = outcome else {
panic!("custom outcome expected, got {outcome:?}");
};
assert_eq!(payload["kind"], json!("Request"), "{payload}");
assert!(
payload["message"]
.as_str()
.is_some_and(|message| message.contains("re-entrant")),
"{payload}"
);
}
#[test]
fn a_grandchild_on_the_ancestors_serial_key_is_refused_too() {
let (dispatcher, _registrar, mut driver) = Bus::channel_with(ServingPolicy {
serial_per_handler: true,
..ServingPolicy::default()
});
driver
.register(
"parent",
Parent {
key: HandlerKey::from("parent"),
child: HandlerKey::from("middle"),
from_another_thread: false,
held: None,
await_child: true,
},
)
.expect("register");
driver
.register(
"middle",
Parent {
key: HandlerKey::from("middle"),
child: HandlerKey::from("parent"),
from_another_thread: false,
held: None,
await_child: true,
},
)
.expect("register");
let mut outer = dispatcher.dispatch(&HandlerKey::from("parent"), custom(json!("outer")));
let outcome = drive_to_outcome(&mut driver, &mut outer)
.expect("resolved, never hung")
.expect("served");
let Outcome::Custom { payload } = outcome else {
panic!("custom outcome expected, got {outcome:?}");
};
assert_eq!(payload["kind"], json!("Request"), "{payload}");
assert!(
payload["message"]
.as_str()
.is_some_and(|message| message.contains("re-entrant")),
"{payload}"
);
let mut middle = dispatcher.dispatch(&HandlerKey::from("middle"), custom(json!("m")));
let outcome = drive_to_outcome(&mut driver, &mut middle)
.expect("resolved, never hung")
.expect("served");
let Outcome::Custom { payload } = outcome else {
panic!("custom outcome expected, got {outcome:?}");
};
assert_eq!(payload["kind"], json!("Request"), "{payload}");
assert!(
payload["message"]
.as_str()
.is_some_and(|message| message.contains("`middle`")),
"{payload}"
);
assert_eq!(driver.in_flight(), 0, "nothing hung behind itself");
}
#[test]
fn a_parent_cancel_reaches_a_child_in_flight_whose_pending_lives_elsewhere() {
let (dispatcher, _registrar, mut driver) = Bus::channel();
let (echo, _never_open) = Echo::gated();
driver.register("echo", echo).expect("register");
let held = Arc::new(Mutex::new(Vec::new()));
driver
.register(
"parent",
Parent {
key: HandlerKey::from("parent"),
child: HandlerKey::from("echo"),
from_another_thread: false,
held: Some(held.clone()),
await_child: false,
},
)
.expect("register");
let mut cx = Context::from_waker(noop_waker_ref());
let outer = dispatcher.dispatch(&HandlerKey::from("parent"), custom(json!("outer")));
let mut outer = Box::pin(outer);
assert!(outer.poll_unpin(&mut cx).is_pending());
let _ = driver.poll_unpin(&mut cx);
let _ = driver.poll_unpin(&mut cx);
assert_eq!(driver.in_flight(), 2, "parent and child in flight");
let mut child = held
.lock()
.expect("held")
.pop()
.expect("the child was parked");
assert!(child.poll_unpin(&mut cx).is_pending(), "gated");
drop(outer);
for _ in 0..4 {
let _ = driver.poll_unpin(&mut cx);
}
let report = child
.poll_unpin(&mut cx)
.map(|result| result.expect_err("cancelled with its parent"));
assert!(
matches!(report, Poll::Ready(ref report) if report.kind == ErrorKind::Cancelled),
"{report:?}"
);
assert_eq!(driver.in_flight(), 0);
}
#[test]
fn a_deferred_child_cannot_answer_success_after_its_parent_is_cancelled() {
let (dispatcher, _registrar, mut driver) = Bus::channel();
let mailbox = Arc::new(Mutex::new(Vec::new()));
driver
.register(
"world",
Detaching {
mailbox: mailbox.clone(),
},
)
.expect("register");
let held = Arc::new(Mutex::new(Vec::new()));
driver
.register(
"parent",
Parent {
key: HandlerKey::from("parent"),
child: HandlerKey::from("world"),
from_another_thread: false,
held: Some(held.clone()),
await_child: false,
},
)
.expect("register");
let mut cx = Context::from_waker(noop_waker_ref());
let mut outer = dispatcher.dispatch(&HandlerKey::from("parent"), custom(json!("outer")));
assert!(outer.poll_unpin(&mut cx).is_pending());
for _ in 0..4 {
let _ = driver.poll_unpin(&mut cx);
}
assert_eq!(driver.in_flight(), 2);
let mut child = held
.lock()
.expect("held")
.pop()
.expect("child retained by host");
let sink = mailbox
.lock()
.expect("mailbox")
.pop()
.expect("sink retained by host");
drop(outer);
for _ in 0..4 {
let _ = driver.poll_unpin(&mut cx);
}
assert!(sink.is_closed(), "driver published ancestor cancellation");
assert_eq!(
driver.in_flight(),
0,
"retaining a closed resolver must not retain driver accounting"
);
let resolve = sink.resolve(Ok(Outcome::Custom {
payload: json!("late success"),
}));
assert!(resolve.is_err());
let report = drive_to_outcome(&mut driver, &mut child)
.expect("resolved")
.expect_err("late host success cannot override ancestor cancellation");
assert_eq!(report.kind, ErrorKind::Cancelled);
for _ in 0..4 {
let _ = driver.poll_unpin(&mut cx);
}
assert_eq!(driver.in_flight(), 0);
}
#[test]
fn a_parent_cancel_reaches_a_child_still_queued() {
let (dispatcher, _registrar, mut driver) = Bus::channel_with(ServingPolicy {
serial_per_handler: true,
..ServingPolicy::default()
});
let (echo, open) = Echo::gated();
driver.register("echo", echo).expect("register");
let held = Arc::new(Mutex::new(Vec::new()));
driver
.register(
"parent",
Parent {
key: HandlerKey::from("parent"),
child: HandlerKey::from("echo"),
from_another_thread: false,
held: Some(held.clone()),
await_child: false,
},
)
.expect("register");
let mut cx = Context::from_waker(noop_waker_ref());
let mut busy = dispatcher.dispatch(&HandlerKey::from("echo"), custom(json!("busy")));
assert!(busy.poll_unpin(&mut cx).is_pending());
let _ = driver.poll_unpin(&mut cx);
let mut outer = dispatcher.dispatch(&HandlerKey::from("parent"), custom(json!("outer")));
assert!(outer.poll_unpin(&mut cx).is_pending());
let _ = driver.poll_unpin(&mut cx);
let _ = driver.poll_unpin(&mut cx);
assert_eq!(
driver.in_flight(),
2,
"busy and parent; the child is queued"
);
assert_eq!(driver.queued(), 1);
let mut child = held
.lock()
.expect("held")
.pop()
.expect("the child was parked");
drop(outer);
let _ = driver.poll_unpin(&mut cx);
open.send(()).expect("gate");
let served = drive_to_outcome(&mut driver, &mut busy)
.expect("resolved")
.expect("the busy one is served");
assert!(
matches!(&served, Outcome::Custom { payload } if *payload == json!("busy")),
"{served:?}"
);
let report = child
.poll_unpin(&mut cx)
.map(|result| result.expect_err("dropped with its parent"));
assert!(
matches!(report, Poll::Ready(ref report) if report.kind == ErrorKind::Cancelled),
"{report:?}"
);
assert_eq!(driver.in_flight(), 0);
assert_eq!(driver.queued(), 0);
}
struct Approval {
asks: std::sync::mpsc::Sender<(EffectId, oneshot::Sender<rig_core::serve::Decision>)>,
}
impl rig_core::serve::Intercept for Approval {
fn name(&self) -> String {
"approval".to_owned()
}
async fn before(&self, id: EffectId, _kind: &EffectKind) -> rig_core::serve::Decision {
let (decide, decided) = oneshot::channel();
self.asks.send((id, decide)).expect("the world listens");
match decided.await {
Ok(decision) => decision,
Err(oneshot::Canceled) => rig_core::serve::Decision::Deny(ErrorReport::new(
ErrorKind::Internal,
"layer `approval`: the world closed the answer channel without deciding",
)),
}
}
async fn after(
&self,
_id: EffectId,
_kind: &EffectKind,
_outcome: &Result<Outcome, ErrorReport>,
) -> rig_core::serve::Verdict {
rig_core::serve::Verdict::Keep
}
}
use rig_core::effect::EffectId;
#[test]
fn a_suspending_layer_keeps_its_serial_slot_and_observes_cancellation() {
let (dispatcher, _registrar, mut driver) = Bus::channel_with(ServingPolicy {
serial_per_handler: true,
..ServingPolicy::default()
});
let (asks, world) = std::sync::mpsc::channel();
let (echo, served) = Echo::new();
driver
.register_erased(
HandlerKey::from("echo"),
rig_core::serve::ErasedHandler::new(echo).layered(Approval { asks }),
)
.expect("register");
assert_eq!(
dispatcher
.descriptor(&HandlerKey::from("echo"))
.expect("published")
.layers,
["approval"],
"the descriptor names the layer"
);
let mut cx = Context::from_waker(noop_waker_ref());
let key = HandlerKey::from("echo");
let mut first = dispatcher.dispatch(&key, custom(json!(1)));
assert!(first.poll_unpin(&mut cx).is_pending());
let _ = driver.poll_unpin(&mut cx);
let (id, decide) = world.try_recv().expect("the world was asked");
assert_eq!(id, first.id());
assert_eq!(driver.in_flight(), 1);
let mut second = dispatcher.dispatch(&key, custom(json!(2)));
assert!(second.poll_unpin(&mut cx).is_pending());
let _ = driver.poll_unpin(&mut cx);
assert_eq!(
driver.queued(),
1,
"the second waits for the suspended first"
);
assert_eq!(served.load(Ordering::SeqCst), 0, "nothing served yet");
drop(first);
let _ = driver.poll_unpin(&mut cx);
assert!(
decide.is_canceled(),
"the world sees the cancel on its sender"
);
assert!(decide.send(rig_core::serve::Decision::Proceed).is_err());
let (_, decide_second) = world.try_recv().expect("the second was asked");
decide_second
.send(rig_core::serve::Decision::Proceed)
.expect("the layer listens");
let outcome = drive_to_outcome(&mut driver, &mut second)
.expect("resolved")
.expect("served");
assert!(matches!(&outcome, Outcome::Custom { payload } if *payload == json!(2)));
assert_eq!(served.load(Ordering::SeqCst), 1);
assert_eq!(driver.in_flight(), 0);
}
#[test]
fn a_suspending_layer_whose_world_closes_the_channel_resolves_internal_naming_the_layer() {
let (dispatcher, _registrar, mut driver) = Bus::channel();
let (asks, world) = std::sync::mpsc::channel();
let (echo, served) = Echo::new();
driver
.register_erased(
HandlerKey::from("echo"),
rig_core::serve::ErasedHandler::new(echo).layered(Approval { asks }),
)
.expect("register");
let mut cx = Context::from_waker(noop_waker_ref());
let mut pending = dispatcher.dispatch(&HandlerKey::from("echo"), custom(json!(1)));
assert!(pending.poll_unpin(&mut cx).is_pending());
let _ = driver.poll_unpin(&mut cx);
let (_, decide) = world.try_recv().expect("asked");
drop(decide);
let report = drive_to_outcome(&mut driver, &mut pending)
.expect("resolved")
.expect_err("the world never decided");
assert_eq!(report.kind, ErrorKind::Internal);
assert!(
report.message.contains("layer `approval`"),
"{}",
report.message
);
assert_eq!(served.load(Ordering::SeqCst), 0);
}
#[test]
fn a_denied_dispatch_is_denied_on_the_consumers_pending_and_leaves_no_record() {
struct Wall;
impl rig_core::serve::Intercept for Wall {
fn name(&self) -> String {
"wall".to_owned()
}
async fn before(&self, _id: EffectId, _kind: &EffectKind) -> rig_core::serve::Decision {
rig_core::serve::Decision::deny("blocked by policy")
}
async fn after(
&self,
_id: EffectId,
_kind: &EffectKind,
_outcome: &Result<Outcome, ErrorReport>,
) -> rig_core::serve::Verdict {
rig_core::serve::Verdict::Keep
}
}
let (dispatcher, _registrar, mut driver) = Bus::channel();
let (echo, served) = Echo::new();
driver
.register_erased(
HandlerKey::from("echo"),
rig_core::serve::ErasedHandler::new(echo).layered(Wall),
)
.expect("register");
let counting = Counting::default();
driver.record_to(counting.clone());
let mut pending = dispatcher.dispatch(&HandlerKey::from("echo"), custom(json!(1)));
let report = drive_to_outcome(&mut driver, &mut pending)
.expect("resolved")
.expect_err("denied");
assert_eq!(report.kind, ErrorKind::Denied);
assert!(!report.retryable);
assert_eq!(served.load(Ordering::SeqCst), 0);
assert_eq!(
counting.begun.load(Ordering::SeqCst),
1,
"the dispatch began"
);
assert_eq!(
counting.discarded.load(Ordering::SeqCst),
1,
"and was discarded"
);
assert_eq!(
counting.resolved.load(Ordering::SeqCst),
0,
"never resolved: no record"
);
}
#[test]
fn cancellation_reaches_grandchild_after_middle_dispatch_completes() {
use super::dispatcher::Shared;
use rig_core::effect::EffectId;
let shared = Shared::new(ServingPolicy::default());
let grandparent = EffectId::from_raw(1);
let middle = EffectId::from_raw(2);
let child = EffectId::from_raw(3);
let _grandparent = shared
.begin_in_flight(grandparent, HandlerKey::from("grandparent"), None)
.ok()
.expect("grandparent active");
let _middle = shared
.begin_in_flight(middle, HandlerKey::from("middle"), Some(grandparent))
.ok()
.expect("middle active");
let child_cancel = shared
.begin_in_flight(child, HandlerKey::from("child"), Some(middle))
.ok()
.expect("child active");
assert!(!shared.end_in_flight(middle));
shared.cancel_descendants(grandparent);
assert!(
child_cancel.is_set(),
"completed intermediate dispatch must not sever cancellation ancestry"
);
}
struct CaptureLineage {
captured: Arc<Mutex<Option<Dispatcher>>>,
complete: bool,
detached: Option<Arc<Mutex<Vec<rig_core::serve::Resolver>>>>,
}
impl Serve for CaptureLineage {
type Family = rig_core::effect::family::Dynamic;
fn descriptor(&self) -> HandlerDescriptor {
HandlerDescriptor {
key: HandlerKey::from("capture"),
family: FamilyDescriptor::Custom {
kind: "capture".into(),
},
layers: Vec::new(),
}
}
async fn serve(&self, _: EffectKind, dispatch: Dispatch) -> CoreReply {
*self.captured.lock().unwrap() = Some(super::DispatchScope::dispatcher(&dispatch).unwrap());
if let Some(detached) = &self.detached {
let (resolver, answer) = rig_core::serve::deferred();
detached.lock().unwrap().push(resolver);
return CoreReply::Outcome(answer.await);
}
if !self.complete {
futures::future::pending::<()>().await;
}
CoreReply::Outcome(Ok(Outcome::Custom {
payload: json!("complete"),
}))
}
}
fn completed_middle_chain(policy: ServingPolicy) -> (Dispatcher, BusDriver, Pending, Dispatcher) {
completed_middle_chain_with_resolver(policy, None)
}
fn completed_middle_chain_with_resolver(
policy: ServingPolicy,
detached: Option<Arc<Mutex<Vec<rig_core::serve::Resolver>>>>,
) -> (Dispatcher, BusDriver, Pending, Dispatcher) {
let (root, _registrar, mut driver) = Bus::channel_with(policy);
let outer_capture = Arc::new(Mutex::new(None));
let middle_capture = Arc::new(Mutex::new(None));
driver
.register(
"outer",
CaptureLineage {
captured: outer_capture.clone(),
complete: false,
detached,
},
)
.unwrap();
driver
.register(
"middle",
CaptureLineage {
captured: middle_capture.clone(),
complete: true,
detached: None,
},
)
.unwrap();
let mut outer = root.dispatch(&HandlerKey::from("outer"), custom(json!(null)));
let mut cx = Context::from_waker(noop_waker_ref());
assert!(outer.poll_unpin(&mut cx).is_pending());
let _ = driver.poll_unpin(&mut cx);
let parent = outer_capture.lock().unwrap().take().unwrap();
let mut middle = parent.dispatch(&HandlerKey::from("middle"), custom(json!(null)));
drive_to_outcome(&mut driver, &mut middle).unwrap().unwrap();
let retained = middle_capture.lock().unwrap().take().unwrap();
assert_eq!(retained.parent(), Some(middle.id()));
assert_eq!(
driver.in_flight(),
1,
"middle completed, outer remains active"
);
(root, driver, outer, retained)
}
#[test]
fn retained_lineage_cancels_unpolled_buffered_active_and_serial_queued_children() {
for stage in 0..4 {
let (root, mut driver, outer, retained) = completed_middle_chain(ServingPolicy {
serial_per_handler: true,
..ServingPolicy::default()
});
let (echo, _gate) = Echo::gated();
driver.register("echo", echo).unwrap();
let mut cx = Context::from_waker(noop_waker_ref());
let _busy = if stage == 3 {
let mut busy = root.dispatch(&HandlerKey::from("echo"), custom(json!("busy")));
assert!(busy.poll_unpin(&mut cx).is_pending());
let _ = driver.poll_unpin(&mut cx);
Some(busy)
} else {
None
};
let mut child = retained.dispatch(&HandlerKey::from("echo"), custom(json!("child")));
if stage > 0 {
assert!(child.poll_unpin(&mut cx).is_pending());
}
if stage > 1 {
let _ = driver.poll_unpin(&mut cx);
}
if stage == 3 {
assert_eq!(driver.queued(), 1);
}
drop(outer);
for _ in 0..4 {
let _ = driver.poll_unpin(&mut cx);
}
let report = drive_to_outcome(&mut driver, &mut child)
.unwrap()
.unwrap_err();
assert_eq!(report.kind, ErrorKind::Cancelled, "stage {stage}");
assert_eq!(driver.queued(), 0);
let mut later = retained
.clone()
.dispatch(&HandlerKey::from("echo"), custom(json!("later")));
assert!(
matches!(later.poll_unpin(&mut cx), Poll::Ready(Err(ref e)) if e.kind == ErrorKind::Cancelled)
);
}
}
#[test]
fn retained_lineage_cancels_parked_unary_and_stream_sends() {
let (root, mut driver, outer, retained) = completed_middle_chain(ServingPolicy {
command_capacity: 1,
..ServingPolicy::default()
});
let mut cx = Context::from_waker(noop_waker_ref());
let mut filler = root.dispatch(&HandlerKey::from("missing"), custom(json!(null)));
assert!(filler.poll_unpin(&mut cx).is_pending());
let mut unary = retained.dispatch(&HandlerKey::from("missing"), custom(json!(null)));
let mut stream = retained.dispatch_stream(
&HandlerKey::from("missing"),
EffectKind::Completion {
request: completion_request_value(),
stream: true,
},
);
assert!(unary.poll_unpin(&mut cx).is_pending());
assert!(stream.poll_next_unpin(&mut cx).is_pending());
assert_eq!(root.shared.parked_senders(), 2);
drop(outer);
for _ in 0..4 {
let _ = driver.poll_unpin(&mut cx);
}
assert!(
matches!(unary.poll_unpin(&mut cx), Poll::Ready(Err(ref e)) if e.kind == ErrorKind::Cancelled)
);
assert!(
matches!(stream.poll_next_unpin(&mut cx), Poll::Ready(Some(Err(ref e))) if e.kind == ErrorKind::Cancelled)
);
assert!(stream.poll_next_unpin(&mut cx).is_ready());
}
#[test]
fn retained_lineage_checks_active_serial_occupancy_past_completed_nodes() {
let (_root, mut driver, outer, retained) = completed_middle_chain(ServingPolicy {
serial_per_handler: true,
..ServingPolicy::default()
});
let mut cx = Context::from_waker(noop_waker_ref());
let mut reentrant = retained.dispatch(&HandlerKey::from("outer"), custom(json!(null)));
assert!(
matches!(reentrant.poll_unpin(&mut cx), Poll::Ready(Err(ref e)) if e.kind == ErrorKind::Request)
);
let mut allowed = retained.dispatch(&HandlerKey::from("middle"), custom(json!(null)));
drive_to_outcome(&mut driver, &mut allowed)
.unwrap()
.unwrap();
drop(outer);
}
#[test]
fn retained_lineage_reclaims_deep_unique_and_shared_chains_without_recursion() {
use super::dispatcher::Lineage;
std::thread::Builder::new()
.stack_size(64 * 1024)
.spawn(|| {
let root = Lineage::new(EffectId::from_raw(1), None);
let weak = Arc::downgrade(&root);
let mut last = root.clone();
for id in 2..10_002 {
last = Lineage::new(EffectId::from_raw(id), Some(last));
}
drop(last);
assert_eq!(Arc::strong_count(&root), 1);
drop(root);
assert!(weak.upgrade().is_none());
})
.unwrap()
.join()
.unwrap();
}
#[test]
fn retained_lineage_refuses_queued_child_while_the_host_retains_a_cancelled_resolver() {
let detached = Arc::new(Mutex::new(Vec::new()));
let (root, mut driver, outer, retained) = completed_middle_chain_with_resolver(
ServingPolicy {
serial_per_handler: true,
..ServingPolicy::default()
},
Some(detached.clone()),
);
let (echo, _gate) = Echo::gated();
driver.register("echo", echo).unwrap();
let mut cx = Context::from_waker(noop_waker_ref());
let mut busy = root.dispatch(&HandlerKey::from("echo"), custom(json!("busy")));
assert!(busy.poll_unpin(&mut cx).is_pending());
let _ = driver.poll_unpin(&mut cx);
let mut child = retained.dispatch(&HandlerKey::from("echo"), custom(json!("child")));
assert!(child.poll_unpin(&mut cx).is_pending());
let _ = driver.poll_unpin(&mut cx);
assert_eq!(driver.queued(), 1);
assert_eq!(driver.in_flight(), 2);
drop(outer);
let _ = driver.poll_unpin(&mut cx);
assert_eq!(
driver.in_flight(),
1,
"only the unrelated blocker remains after ancestor cancellation"
);
assert!(detached.lock().unwrap()[0].is_closed());
assert!(
matches!(child.poll_unpin(&mut cx), Poll::Ready(Err(ref report)) if report.kind == ErrorKind::Cancelled)
);
assert_eq!(driver.queued(), 0);
}
#[test]
fn full_consumer_queue_stops_pulls_and_ancestor_cancellation_keeps_its_terminal() {
struct ReadyStream(Arc<AtomicUsize>, Arc<AtomicUsize>);
impl Serve for ReadyStream {
type Family = rig_core::effect::family::Dynamic;
fn descriptor(&self) -> HandlerDescriptor {
HandlerDescriptor {
key: "ready".into(),
family: FamilyDescriptor::Custom {
kind: "ready".into(),
},
layers: vec![],
}
}
async fn serve(&self, _: EffectKind, _: Dispatch) -> CoreReply {
struct Guard(Arc<AtomicUsize>);
impl Drop for Guard {
fn drop(&mut self) {
self.0.fetch_add(1, Ordering::SeqCst);
}
}
let guard = Guard(self.1.clone());
let polls = self.0.clone();
CoreReply::Stream(Box::pin(futures::stream::poll_fn(move |_| {
let _guard = &guard;
polls.fetch_add(1, Ordering::SeqCst);
Poll::Ready(Some(Ok(Relayed::Item(Item::Unknown(
rig_core::streaming::UnknownPayload::new(json!(null)),
)))))
})))
}
}
let (root, mut driver, outer, retained) = completed_middle_chain(ServingPolicy {
stream_capacity: 1,
..ServingPolicy::default()
});
let polls = Arc::new(AtomicUsize::new(0));
let drops = Arc::new(AtomicUsize::new(0));
driver
.register("ready", ReadyStream(polls.clone(), drops.clone()))
.unwrap();
let mut stream = retained.dispatch_stream(&HandlerKey::from("ready"), completion_kind(true));
let mut cx = Context::from_waker(noop_waker_ref());
assert!(stream.poll_next_unpin(&mut cx).is_pending());
for _ in 0..4 {
let _ = driver.poll_unpin(&mut cx);
}
let stalled = polls.load(Ordering::SeqCst);
assert!(
(1..=3).contains(&stalled),
"one queue slot, one sender reservation, at most one undelivered item: {stalled}"
);
for _ in 0..4 {
let _ = driver.poll_unpin(&mut cx);
}
assert_eq!(polls.load(Ordering::SeqCst), stalled);
let mut other = root.dispatch(&HandlerKey::from("missing"), custom(json!(null)));
assert_eq!(
drive_to_outcome(&mut driver, &mut other)
.unwrap()
.unwrap_err()
.kind,
ErrorKind::HandlerUnavailable
);
drop(outer);
for _ in 0..4 {
let _ = driver.poll_unpin(&mut cx);
}
assert_eq!(drops.load(Ordering::SeqCst), 1);
assert_eq!(
polls.load(Ordering::SeqCst),
stalled,
"cancellation must not pull another item"
);
let mut delivered = 0;
loop {
match stream.poll_next_unpin(&mut cx) {
Poll::Ready(Some(Ok(_))) => delivered += 1,
Poll::Ready(Some(Err(error))) => {
assert_eq!(error.kind, ErrorKind::Cancelled);
break;
}
other => panic!("the full queue lost its cancellation terminal: {other:?}"),
}
}
assert!(delivered <= stalled);
assert!(matches!(stream.poll_next_unpin(&mut cx), Poll::Ready(None)));
assert_eq!(driver.in_flight(), 0);
}
#[tokio::test]
async fn labelled_memory_and_retrieve_adapters_serve_side_by_side() {
use rig_core::effect::{MemoryOp, MemoryOutcome, memory_key, retrieve_key};
use rig_core::serve::adapters::{MemoryAdapter, RetrieveAdapter};
use rig_core::test_utils::CountingMemory;
let (dispatcher, _registrar, mut driver) = Bus::channel();
let tenant_a = CountingMemory::default();
let tenant_b = CountingMemory::default();
driver
.register("memory:a", MemoryAdapter::labelled("a", tenant_a.clone()))
.expect("first memory");
driver
.register("memory:b", MemoryAdapter::labelled("b", tenant_b.clone()))
.expect("second memory");
driver
.register(
"retrieve:docs",
RetrieveAdapter::labelled("docs", crate::test_utils::MockToolIndex::new(["t1"])),
)
.expect("first index");
driver
.register(
"retrieve:code",
RetrieveAdapter::labelled("code", crate::test_utils::MockToolIndex::new(["t2"])),
)
.expect("second index");
assert_eq!(memory_key("a"), HandlerKey::from("memory:a"));
assert_eq!(retrieve_key("code"), HandlerKey::from("retrieve:code"));
let _task = spawn(driver);
let conversation = rig_core::id::ConversationId::from("c1");
within(dispatcher.dispatch(
&memory_key("a"),
EffectKind::Memory {
op: MemoryOp::Append {
conversation: conversation.clone(),
messages: vec![Message::user("only in a")],
},
},
))
.await
.expect("appended to a");
for (label, expected) in [("a", 1), ("b", 0)] {
let loaded = within(dispatcher.dispatch(
&memory_key(label),
EffectKind::Memory {
op: MemoryOp::Load {
conversation: conversation.clone(),
},
},
))
.await
.expect("loaded");
assert!(
matches!(loaded, Outcome::Memory(MemoryOutcome::Loaded { ref messages }) if messages.len() == expected),
"memory:{label} holds its own conversation: {loaded:?}"
);
}
assert_eq!(tenant_a.load_count(), 1);
assert_eq!(tenant_b.load_count(), 1);
}