#![cfg(test)]
use std::error::Error;
use std::future::Future;
use std::num::NonZeroU64;
use std::pin::Pin;
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::{Arc, Barrier};
use std::task::{Context, Poll, Waker};
use crate::cancel::Token;
use futures_core::Stream;
use tokio::task::yield_now;
use tokio::time::{Duration, timeout};
use super::event::testing;
use super::event::testing::{
DecisionProbe, FreezePoint, control, fail, forged, input_admitted, input_rejected, intent,
invalid_audit, invalid_stop, lifecycle, pause_after_final_confirm, pause_before_reject,
register_probe, stale_pending_guard_preserves_successor, stop, text, tool_call,
tool_emitter_active, tool_result,
};
use super::event::{
DecisionError, DecisionPoint, DeliveryOutcome, Event, InputOrigin, Kind, StopCode,
StreamTakenError, StrongDecision, TerminalIntent, ValidationError, channel,
};
use super::event::{ToolEmitError, ToolEmitter, tool_emitter};
use crate::audit;
use crate::opaque::Payload;
use crate::redact_tests::{SECRET, assert_redacted, assert_states};
use crate::transcript::item::{self, Item, ModelVisibility, User};
use crate::value::content::{Metadata, Part};
use crate::value::lifecycle::{Coord, Outcome, StepIndex};
use crate::value::tool_call::{self, Id, ToolCall, ToolResult};
fn assert_pending_once<F: Future + ?Sized>(future: Pin<&mut F>, message: &str) {
let mut context = Context::from_waker(Waker::noop());
assert!(
matches!(future.poll(&mut context), Poll::Pending),
"{message}"
);
}
#[derive(Debug)]
enum FixtureError {
ModelBlocked,
AgentClosed,
}
impl std::fmt::Display for FixtureError {
fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str(match self {
Self::ModelBlocked => "reef: model request blocked",
Self::AgentClosed => "reef: agent closed",
})
}
}
impl Error for FixtureError {}
fn coord() -> Coord {
let one = NonZeroU64::MIN;
Coord::at_tool_call(
"session".into(),
"run".into(),
StepIndex::new(one, one, one).expect("valid"),
one,
"call".into(),
"tool".into(),
)
.expect("valid")
}
fn call(id: &str, name: &str) -> ToolCall {
ToolCall::new(
Id::new(id.into()),
tool_call::Name::new(name.into()),
Payload::copy_from_slice(b"{}"),
)
}
fn result(id: &str, name: &str) -> item::ToolResult {
item::ToolResult::new(
Id::new(id.into()),
tool_call::Name::new(name.into()),
ToolResult::no_output(),
ModelVisibility::Visible,
Some(Metadata::new()),
)
}
fn seam_event(seam: DecisionPoint) -> Event {
match seam {
DecisionPoint::ToolCall => tool_call(call("call", "tool"), coord()),
DecisionPoint::ToolResult => tool_result(result("call", "tool"), coord()),
DecisionPoint::AfterToolCommit => {
Event::from_audit(audit::Event::new("after".into(), None)).expect("valid")
}
}
}
#[test]
fn public_extension_events_and_accessors_are_validated() {
assert_eq!(
Event::from_audit(audit::Event::new(String::new(), None)).err(),
Some(ValidationError::EmptyAuditKind)
);
let audit = Event::from_audit(audit::Event::new(
"progress".into(),
Some(Box::from(*b"ok")),
))
.expect("valid");
assert_eq!(audit.kind(), Kind::Audit);
assert_eq!(audit.as_audit().map(audit::Event::kind), Some("progress"));
assert!(audit.coord().is_none());
assert!(audit.text().is_none());
assert!(audit.tool_call().is_none());
assert!(audit.tool_result().is_none());
assert!(audit.outcome().is_none());
assert!(audit.as_error().is_none());
assert!(audit.stop_code().is_none());
let error = Event::from_error(Arc::new(FixtureError::ModelBlocked));
assert_eq!(error.kind(), Kind::Error);
assert_eq!(
error.as_error().map(ToString::to_string).as_deref(),
Some("reef: model request blocked")
);
assert!(error.as_audit().is_none());
}
#[test]
fn private_variants_expose_only_read_views() {
let location = coord();
for kind in [
Kind::TextDelta,
Kind::Text,
Kind::ThinkingDelta,
Kind::Thinking,
] {
let event = text(kind, "chunk", location.clone());
assert_eq!(event.kind(), kind);
assert_eq!(event.text(), Some("chunk"));
assert_eq!(event.coord(), Some(&location));
}
for (kind, outcome) in [
(Kind::TurnStart, None),
(Kind::TurnEnd, Some(Outcome::Completed)),
(Kind::StepStart, None),
(Kind::StepEnd, Some(Outcome::Stopped)),
(Kind::GenerationEnd, Some(Outcome::Cancelled)),
] {
let event = lifecycle(kind, outcome, location.clone());
assert_eq!(event.outcome(), outcome);
}
let call = tool_call(call("call", "tool"), location.clone());
assert_eq!(
call.tool_call().map(|value| value.id().as_str()),
Some("call")
);
let result = tool_result(result("call", "tool"), location.clone());
assert_eq!(
result.tool_result().map(|value| value.call_id().as_str()),
Some("call")
);
let code = StopCode::new("budget".into()).expect("valid");
assert_eq!(code.as_str(), "budget");
let stopped = stop(code, location);
assert_eq!(stopped.stop_code().map(StopCode::as_str), Some("budget"));
assert_eq!(
StopCode::new(String::new()).err(),
Some(ValidationError::EmptyStopCode)
);
}
#[tokio::test]
async fn producer_authority_constructs_and_stamps_ordinary_events() {
let (producer, mut source) = channel(&Token::new());
assert_eq!(intent(&source), TerminalIntent::Running);
let mut stream = source.take_stream().expect("stream");
assert_eq!(
producer
.emit_text(Kind::Text, "answer".into(), coord(), None)
.await
.expect("valid"),
DeliveryOutcome::Delivered,
);
assert_eq!(
producer
.emit_lifecycle(Kind::StepEnd, Some(Outcome::Completed), coord())
.await
.expect("valid"),
DeliveryOutcome::Delivered,
);
assert_eq!(
producer
.emit_extension(
Event::from_audit(audit::Event::new("extension".into(), None)).expect("valid"),
coord(),
)
.await
.expect("valid"),
DeliveryOutcome::Delivered,
);
let text = stream.recv().await.expect("text");
let lifecycle = stream.recv().await.expect("lifecycle");
let extension = stream.recv().await.expect("extension");
assert_eq!(text.event().text(), Some("answer"));
assert_eq!(lifecycle.event().outcome(), Some(Outcome::Completed));
assert_eq!(extension.event().coord().map(Coord::run_id), Some("run"));
}
#[tokio::test]
async fn parent_cancellation_uses_a_child_token_and_maps_terminal_outcomes() {
for (terminal, outcome) in [
(TerminalIntent::Running, None),
(TerminalIntent::Stopped, Some(Outcome::Stopped)),
(TerminalIntent::Cancelled, Some(Outcome::Cancelled)),
(TerminalIntent::Failed, Some(Outcome::Failed)),
] {
assert_eq!(terminal.outcome(), outcome);
}
let parent = Token::new();
let (producer, source) = channel(&parent);
assert_eq!(intent(&source), TerminalIntent::Running);
parent.cancel();
assert_eq!(control(&source), (false, false, true));
assert_eq!(intent(&source), TerminalIntent::Cancelled);
assert_eq!(intent(&source).outcome(), Some(Outcome::Cancelled));
assert_eq!(
producer
.emit_text(Kind::Text, "canceled".into(), coord(), None)
.await
.expect("parent cancellation rejects emission"),
DeliveryOutcome::Rejected
);
assert_eq!(
producer
.emit_tool_call(call("canceled", "tool"), coord())
.await
.expect("strong producer preserves parent cancellation"),
StrongDecision::Cancelled
);
assert_eq!(
producer
.emit(
seam_event(DecisionPoint::ToolCall),
Some(DecisionPoint::ToolCall),
)
.await
.expect("legacy delivery outcome remains fail-closed"),
DeliveryOutcome::Rejected
);
assert_eq!(
producer
.emit_stop(StopCode::new("canceled".into()).expect("valid"), coord())
.await
.expect("parent cancellation rejects stop delivery"),
DeliveryOutcome::Rejected
);
let independent_parent = Token::new();
let (_producer, independent_source) = channel(&independent_parent);
independent_source.request_stop();
assert!(
!independent_parent.is_cancelled(),
"canceling a run child must not cancel its parent"
);
}
#[tokio::test]
async fn every_decision_point_accepts_rejects_and_guard_drops() {
for seam in [
DecisionPoint::ToolCall,
DecisionPoint::ToolResult,
DecisionPoint::AfterToolCommit,
] {
for action in 0..3 {
let (producer, mut source) = channel(&Token::new());
let mut stream = source.take_stream().expect("first consumer");
let task = tokio::spawn(async move {
match seam {
DecisionPoint::ToolCall => {
producer.emit_tool_call(call("call", "tool"), coord()).await
}
DecisionPoint::ToolResult => {
producer
.emit_tool_result(result("call", "tool"), coord())
.await
}
DecisionPoint::AfterToolCommit => {
producer
.emit_after_tool_commit(
Event::from_audit(audit::Event::new("after".into(), None))
.expect("valid"),
coord(),
)
.await
}
}
});
let delivery = stream.recv().await.expect("delivery");
assert_eq!(delivery.decision_point(), Some(seam));
assert_eq!(delivery.event().coord().map(Coord::run_id), Some("run"));
match action {
0 => delivery.accept().expect("accept"),
1 => delivery.reject().expect("reject"),
_ => drop(delivery),
}
let expected = if action == 0 {
StrongDecision::Accepted
} else {
StrongDecision::Rejected
};
assert_eq!(task.await.expect("join").expect("valid"), expected);
}
}
}
#[tokio::test]
async fn dropping_producer_future_abandons_every_strong_delivery_before_clearing_pending() {
for seam in [
DecisionPoint::ToolCall,
DecisionPoint::ToolResult,
DecisionPoint::AfterToolCommit,
] {
let (producer, mut source) = channel(&Token::new());
let mut stream = source.take_stream().expect("stream");
let task = tokio::spawn(async move {
match seam {
DecisionPoint::ToolCall => {
producer.emit_tool_call(call("old", "tool"), coord()).await
}
DecisionPoint::ToolResult => {
producer
.emit_tool_result(result("old", "tool"), coord())
.await
}
DecisionPoint::AfterToolCommit => {
producer
.emit_after_tool_commit(
Event::from_audit(audit::Event::new("old-after".into(), None)).unwrap(),
coord(),
)
.await
}
}
});
let abandoned = stream.recv().await.expect("old delivery");
task.abort();
assert!(
task.await
.expect_err("producer owner was dropped")
.is_cancelled()
);
assert_eq!(abandoned.accept(), Err(DecisionError::AlreadyDecided));
assert_eq!(abandoned.reject(), Err(DecisionError::AlreadyDecided));
assert!(!super::event::testing::has_pending_strong_decision(&source));
}
}
#[test]
fn stale_pending_guard_abandons_only_itself_and_cannot_clear_a_successor() {
let (_producer, source) = channel(&Token::new());
assert_eq!(
stale_pending_guard_preserves_successor(&source),
(true, true)
);
assert!(!super::event::testing::has_pending_strong_decision(&source));
}
#[tokio::test]
async fn pending_parent_cancellation_is_distinct_from_consumer_rejection_at_every_decision_point() {
for seam in [
DecisionPoint::ToolCall,
DecisionPoint::ToolResult,
DecisionPoint::AfterToolCommit,
] {
let parent = Token::new();
let (producer, mut source) = channel(&parent);
let mut stream = source.take_stream().expect("stream");
let task = tokio::spawn(async move {
match seam {
DecisionPoint::ToolCall => {
producer.emit_tool_call(call("call", "tool"), coord()).await
}
DecisionPoint::ToolResult => {
producer
.emit_tool_result(result("call", "tool"), coord())
.await
}
DecisionPoint::AfterToolCommit => {
producer
.emit_after_tool_commit(
Event::from_audit(audit::Event::new("after".into(), None))
.expect("valid"),
coord(),
)
.await
}
}
});
let pending = stream.recv().await.expect("pending strong delivery");
parent.cancel();
assert_eq!(
task.await.expect("join").expect("valid"),
StrongDecision::Cancelled
);
assert_eq!(pending.reject(), Err(DecisionError::AlreadyDecided));
let (producer, mut source) = channel(&Token::new());
let mut stream = source.take_stream().expect("stream");
let task = tokio::spawn(async move {
match seam {
DecisionPoint::ToolCall => {
producer.emit_tool_call(call("call", "tool"), coord()).await
}
DecisionPoint::ToolResult => {
producer
.emit_tool_result(result("call", "tool"), coord())
.await
}
DecisionPoint::AfterToolCommit => {
producer
.emit_after_tool_commit(
Event::from_audit(audit::Event::new("after".into(), None))
.expect("valid"),
coord(),
)
.await
}
}
});
let rejected = stream.recv().await.expect("consumer-owned strong delivery");
rejected.reject().expect("consumer rejection linearizes");
assert_eq!(
task.await.expect("join").expect("valid"),
StrongDecision::Rejected
);
}
}
#[tokio::test]
async fn parent_cancellation_while_strong_send_is_backpressured_is_canceled() {
let parent = Token::new();
let (producer, mut source) = channel(&parent);
let stream = source.take_stream().expect("stream");
assert_eq!(
producer
.emit(
Event::from_audit(audit::Event::new("fills-channel".into(), None)).expect("valid"),
None,
)
.await
.expect("ordinary fill"),
DeliveryOutcome::Delivered
);
let blocked = producer.emit_tool_call(call("blocked", "tool"), coord());
tokio::pin!(blocked);
assert_pending_once(
blocked.as_mut(),
"the strong emission must wait at its registered decision",
);
assert!(testing::has_pending_strong_decision(&source));
parent.cancel();
assert_eq!(blocked.await.expect("valid"), StrongDecision::Cancelled);
drop(stream);
}
#[tokio::test]
async fn ordinary_delivery_has_no_hidden_ack() {
let (producer, mut source) = channel(&Token::new());
let mut stream = source.take_stream().expect("stream");
let event = Event::from_audit(audit::Event::new("ordinary".into(), None)).expect("valid");
let task = tokio::spawn(async move { producer.emit(event, None).await });
let delivery = stream.recv().await.expect("delivery");
assert_eq!(delivery.decision_point(), None);
assert_eq!(delivery.accept(), Err(DecisionError::NotRequired));
assert_eq!(delivery.reject(), Err(DecisionError::NotRequired));
assert_eq!(
task.await.expect("join").expect("valid"),
DeliveryOutcome::Delivered
);
let (producer, mut source) = channel(&Token::new());
let mut stream = source.take_stream().expect("stream");
let ordinary_error = Event::from_error(Arc::new(FixtureError::AgentClosed));
assert_eq!(
producer.emit(ordinary_error, None).await.expect("valid"),
DeliveryOutcome::Delivered
);
let delivery = stream.recv().await.expect("ordinary error");
assert_eq!(delivery.event().kind(), Kind::Error);
let (producer, mut source) = channel(&Token::new());
let mut stream = source.take_stream().expect("stream");
let task = tokio::spawn(async move {
producer
.emit(
Event::from_error(Arc::new(FixtureError::AgentClosed)),
Some(DecisionPoint::AfterToolCommit),
)
.await
});
let delivery = stream.recv().await.expect("after-tool error");
delivery.accept().expect("accept");
assert_eq!(
task.await.expect("join").expect("valid"),
DeliveryOutcome::Accepted
);
}
#[tokio::test(flavor = "current_thread")]
async fn accept_reject_race_has_one_linearization_point() {
let (producer, mut source) = channel(&Token::new());
let mut stream = source.take_stream().expect("stream");
let task = tokio::spawn(async move {
producer
.emit(
seam_event(DecisionPoint::ToolCall),
Some(DecisionPoint::ToolCall),
)
.await
});
let delivery = Arc::new(stream.recv().await.expect("delivery"));
let barrier = Arc::new(Barrier::new(3));
let accept = {
let delivery = delivery.clone();
let barrier = barrier.clone();
std::thread::spawn(move || {
barrier.wait();
delivery.accept()
})
};
let reject = {
let delivery = delivery.clone();
let barrier = barrier.clone();
std::thread::spawn(move || {
barrier.wait();
delivery.reject()
})
};
barrier.wait();
let first = accept.join().expect("accept thread");
let second = reject.join().expect("reject thread");
assert_ne!(first.is_ok(), second.is_ok());
assert_eq!(
first.err().or(second.err()),
Some(DecisionError::AlreadyDecided)
);
let outcome = task.await.expect("join").expect("valid");
assert!(matches!(
outcome,
DeliveryOutcome::Accepted | DeliveryOutcome::Rejected
));
let duplicate = if outcome == DeliveryOutcome::Accepted {
delivery.accept()
} else {
delivery.reject()
};
assert_eq!(duplicate, Err(DecisionError::AlreadyDecided));
}
#[tokio::test]
async fn decision_wait_cannot_lose_notify_before_poll_or_after_state_check() {
let cancellation = Token::new();
let before_poll = DecisionProbe::plain(cancellation.clone());
let wait = before_poll.wait();
tokio::pin!(wait);
before_poll.accept().expect("accept before the first poll");
assert_eq!(
timeout(Duration::from_millis(50), &mut wait)
.await
.expect("pre-poll notification cannot be lost"),
StrongDecision::Accepted
);
let (after_check, checked, resume) =
DecisionProbe::paused_after_pending_check(cancellation.clone());
let deciding = {
let decision = after_check.clone();
std::thread::spawn(move || {
checked.wait();
let result = decision.accept();
resume.wait();
result
})
};
assert_eq!(
timeout(Duration::from_millis(50), after_check.wait())
.await
.expect("notification after the state check cannot be lost"),
StrongDecision::Accepted
);
deciding
.join()
.expect("decision thread")
.expect("accept after state check");
let canceled = DecisionProbe::plain(cancellation.clone());
cancellation.cancel();
assert_eq!(canceled.wait().await, StrongDecision::Cancelled);
assert_eq!(canceled.accept(), Err(DecisionError::AlreadyDecided));
}
#[tokio::test]
async fn cancellation_is_biased_over_consumer_rejection_when_both_wake_the_same_wait_poll() {
let cancellation = Token::new();
let (decision, checked, resume) =
DecisionProbe::paused_after_pending_check(cancellation.clone());
let competing = {
let cancellation = cancellation.clone();
let decision = decision.clone();
std::thread::spawn(move || {
checked.wait();
cancellation.cancel();
let rejection = decision.reject();
resume.wait();
rejection
})
};
assert_eq!(decision.wait().await, StrongDecision::Cancelled);
assert_eq!(
competing.join().expect("consumer decision thread"),
Err(DecisionError::AlreadyDecided),
"a consumer cannot replace an already-visible parent cancellation"
);
let cancellation = Token::new();
let rejected = DecisionProbe::plain(cancellation.clone());
rejected
.reject()
.expect("consumer rejection linearizes first");
cancellation.cancel();
assert_eq!(rejected.wait().await, StrongDecision::Rejected);
}
#[tokio::test]
async fn cancellation_and_stream_drop_fail_closed_and_release_pending() {
let (producer, mut source) = channel(&Token::new());
let mut stream = source.take_stream().expect("stream");
let task = tokio::spawn(async move {
producer
.emit(
seam_event(DecisionPoint::ToolResult),
Some(DecisionPoint::ToolResult),
)
.await
});
let delivery = stream.recv().await.expect("pending");
source.request_stop();
assert_eq!(
task.await.expect("join").expect("valid"),
DeliveryOutcome::Rejected
);
assert_eq!(delivery.accept(), Err(DecisionError::AlreadyDecided));
assert_eq!(control(&source), (true, false, true));
let (producer, mut source) = channel(&Token::new());
let stream = source.take_stream().expect("stream");
let task = producer.emit(
seam_event(DecisionPoint::AfterToolCommit),
Some(DecisionPoint::AfterToolCommit),
);
tokio::pin!(task);
assert_pending_once(
task.as_mut(),
"the strong emission must wait at its registered decision",
);
assert!(testing::has_pending_strong_decision(&source));
drop(stream);
assert_eq!(task.await.expect("valid"), DeliveryOutcome::Rejected);
assert!(!super::event::testing::has_pending_strong_decision(&source));
assert_eq!(control(&source), (true, false, true));
let (producer, mut source) = channel(&Token::new());
let mut stream = source.take_stream().expect("stream");
let seam = producer.emit(
seam_event(DecisionPoint::ToolResult),
Some(DecisionPoint::ToolResult),
);
tokio::pin!(seam);
assert_pending_once(
seam.as_mut(),
"the strong emission must hold the serialized boundary",
);
assert!(testing::has_pending_strong_decision(&source));
let pending_seam = stream.recv().await.expect("the strong seam is delivered");
let blocked = producer.emit(
Event::from_audit(audit::Event::new("blocked".into(), None)).expect("valid"),
None,
);
tokio::pin!(blocked);
assert_pending_once(
blocked.as_mut(),
"the ordinary emission must wait behind the strong emission's serial lock",
);
source.request_stop();
assert_eq!(seam.await.expect("valid"), DeliveryOutcome::Rejected);
assert_eq!(blocked.await.expect("valid"), DeliveryOutcome::Rejected);
drop(pending_seam);
drop(stream);
}
#[tokio::test]
async fn stream_is_single_consumer_and_closed_transport_is_rejection() {
let (producer, mut source) = channel(&Token::new());
let stream = source.take_stream().expect("first");
assert_eq!(source.take_stream().err(), Some(StreamTakenError));
drop(stream);
let outcome = producer
.emit(
seam_event(DecisionPoint::ToolCall),
Some(DecisionPoint::ToolCall),
)
.await;
assert_eq!(outcome.expect("valid"), DeliveryOutcome::Rejected);
}
#[tokio::test]
async fn invalid_payload_or_seam_latches_fatal_and_publishes_nothing() {
for (event, seam, error) in [
(
tool_call(call("", "tool"), coord()),
Some(DecisionPoint::ToolCall),
ValidationError::EmptyToolCallId,
),
(
tool_call(call("id", ""), coord()),
Some(DecisionPoint::ToolCall),
ValidationError::EmptyToolName,
),
(
tool_result(result("", "tool"), coord()),
Some(DecisionPoint::ToolResult),
ValidationError::EmptyToolCallId,
),
(
tool_result(result("id", ""), coord()),
Some(DecisionPoint::ToolResult),
ValidationError::EmptyToolName,
),
(
invalid_audit(coord()),
None,
ValidationError::EmptyAuditKind,
),
(invalid_stop(coord()), None, ValidationError::EmptyStopCode),
(
forged(Kind::Audit, text(Kind::Text, "wrong", coord())),
None,
ValidationError::PayloadMismatch,
),
(
Event::from_audit(audit::Event::new("audit".into(), None)).expect("valid"),
Some(DecisionPoint::ToolCall),
ValidationError::InvalidDecisionPoint,
),
] {
let (producer, mut source) = channel(&Token::new());
let mut stream = source.take_stream().expect("stream");
assert_eq!(producer.emit(event, seam).await.err(), Some(error));
assert_eq!(control(&source), (false, true, true));
let next = stream.recv();
tokio::pin!(next);
assert_pending_once(next.as_mut(), "invalid events never reach the stream");
let later = tool_call(call("later", "tool"), coord());
assert_eq!(
producer
.emit(later, Some(DecisionPoint::ToolCall))
.await
.expect("valid"),
DeliveryOutcome::Rejected
);
}
}
#[tokio::test]
async fn all_non_strong_kinds_reject_an_acceptance_seam() {
let location = coord();
for event in [
text(Kind::Text, "x", location.clone()),
lifecycle(Kind::TurnStart, None, location.clone()),
stop(
StopCode::new("stop".into()).expect("valid"),
location.clone(),
),
] {
let (producer, _source) = channel(&Token::new());
assert_eq!(
producer
.emit(event, Some(DecisionPoint::AfterToolCommit))
.await
.err(),
Some(ValidationError::InvalidDecisionPoint),
);
}
}
#[tokio::test]
async fn concurrent_emits_are_serialized_without_sync_lock_across_await() {
let (producer, mut source) = channel(&Token::new());
let mut stream = source.take_stream().expect("stream");
let first = {
let producer = producer.clone();
tokio::spawn(async move {
producer
.emit(
Event::from_audit(audit::Event::new("one".into(), None)).expect("valid"),
None,
)
.await
})
};
let second = {
let producer = producer.clone();
tokio::spawn(async move {
producer
.emit(
Event::from_audit(audit::Event::new("two".into(), None)).expect("valid"),
None,
)
.await
})
};
let a = stream.recv().await.expect("first");
let b = stream.recv().await.expect("second");
let kinds = [
a.event().as_audit().expect("audit").kind(),
b.event().as_audit().expect("audit").kind(),
];
assert!(kinds == ["one", "two"] || kinds == ["two", "one"]);
assert_eq!(
first.await.expect("join").expect("valid"),
DeliveryOutcome::Delivered
);
assert_eq!(
second.await.expect("join").expect("valid"),
DeliveryOutcome::Delivered
);
}
#[tokio::test]
async fn nonfatal_cause_freezes_first_and_fatal_upgrades_every_ordering() {
let parent = Token::new();
let (_producer, source) = channel(&parent);
parent.cancel();
assert_eq!(intent(&source), TerminalIntent::Cancelled);
source.request_stop();
assert_eq!(intent(&source), TerminalIntent::Cancelled);
assert_eq!(control(&source), (false, false, true));
fail(&source);
assert_eq!(intent(&source), TerminalIntent::Failed);
let parent = Token::new();
let (_producer, source) = channel(&parent);
source.request_stop();
parent.cancel();
assert_eq!(intent(&source), TerminalIntent::Stopped);
assert_eq!(control(&source), (true, false, true));
fail(&source);
assert_eq!(intent(&source), TerminalIntent::Failed);
let parent = Token::new();
let (_producer, mut source) = channel(&parent);
drop(source.take_stream().expect("stream drop is a normal stop"));
parent.cancel();
assert_eq!(intent(&source), TerminalIntent::Stopped);
let parent = Token::new();
let (_producer, source) = channel(&parent);
fail(&source);
parent.cancel();
source.request_stop();
assert_eq!(intent(&source), TerminalIntent::Failed);
}
#[tokio::test]
async fn pending_decision_uses_the_frozen_nonfatal_cause_not_the_child_token() {
for cancel_first in [true, false] {
let parent = Token::new();
let (producer, mut source) = channel(&parent);
let mut stream = source.take_stream().expect("stream");
let task = tokio::spawn(async move {
producer
.emit_tool_call(call("pending", "tool"), coord())
.await
});
let pending = stream.recv().await.expect("pending tool call");
if cancel_first {
parent.cancel();
source.request_stop();
} else {
source.request_stop();
parent.cancel();
}
assert_eq!(
task.await.expect("producer joined").expect("valid event"),
if cancel_first {
StrongDecision::Cancelled
} else {
StrongDecision::Rejected
}
);
assert_eq!(pending.accept(), Err(DecisionError::AlreadyDecided));
assert!(!super::event::testing::has_pending_strong_decision(&source));
assert_eq!(
intent(&source),
if cancel_first {
TerminalIntent::Cancelled
} else {
TerminalIntent::Stopped
}
);
}
}
#[tokio::test]
async fn stop_and_drop_orderings_are_idempotent_and_fatal_has_priority() {
for drop_first in [false, true] {
let (producer, mut source) = channel(&Token::new());
let mut stream = source.take_stream().expect("stream");
let task = tokio::spawn(async move {
producer
.emit(
seam_event(DecisionPoint::ToolCall),
Some(DecisionPoint::ToolCall),
)
.await
});
let delivery = stream.recv().await.expect("barrier reached");
if drop_first {
drop(stream);
source.request_stop();
} else {
source.request_stop();
drop(stream);
}
assert_eq!(delivery.accept(), Err(DecisionError::AlreadyDecided));
assert_eq!(
task.await.expect("exactly one join").expect("valid"),
DeliveryOutcome::Rejected
);
assert_eq!(control(&source), (true, false, true));
assert_eq!(intent(&source), TerminalIntent::Stopped);
}
let (producer, mut source) = channel(&Token::new());
let mut stream = source.take_stream().expect("stream");
let task = tokio::spawn(async move {
producer
.emit(
seam_event(DecisionPoint::ToolCall),
Some(DecisionPoint::ToolCall),
)
.await
});
let delivery = stream.recv().await.expect("delivery");
delivery.accept().expect("internal accept first");
source.request_stop();
assert_eq!(
task.await.expect("join").expect("valid"),
DeliveryOutcome::Rejected,
"consumer acceptance alone is not caller authorization before final confirmation"
);
let (producer, source) = channel(&Token::new());
let invalid = tool_call(call("", "tool"), coord());
assert_eq!(
producer
.emit(invalid, Some(DecisionPoint::ToolCall))
.await
.err(),
Some(ValidationError::EmptyToolCallId),
);
source.request_stop();
assert_eq!(control(&source), (true, true, true));
assert_eq!(intent(&source), TerminalIntent::Failed);
let (producer, source) = channel(&Token::new());
source.request_stop();
assert_eq!(
producer
.emit(
tool_call(call("", "tool"), coord()),
Some(DecisionPoint::ToolCall),
)
.await
.expect("stop won"),
DeliveryOutcome::Rejected,
);
assert_eq!(control(&source), (true, false, true));
assert!(register_probe(&source));
let (_producer, source) = channel(&Token::new());
fail(&source);
assert!(register_probe(&source));
assert_eq!(control(&source), (false, true, true));
}
#[tokio::test]
async fn frozen_stop_or_fatal_overrides_consumer_acceptance_before_caller_execution() {
for point in [FreezePoint::Stop, FreezePoint::Fatal] {
let (producer, mut source) = channel(&Token::new());
let mut stream = source.take_stream().expect("stream");
let executions = Arc::new(AtomicUsize::new(0));
let caller_executions = Arc::clone(&executions);
let task = tokio::spawn(async move {
let outcome = producer
.emit_tool_call(call("pending", "tool"), coord())
.await?;
if outcome == StrongDecision::Accepted {
caller_executions.fetch_add(1, Ordering::AcqRel);
}
Ok::<_, ValidationError>(outcome)
});
let delivery = stream.recv().await.expect("pending ToolCall");
let (control, pause) = pause_before_reject(&source, point);
let interruption = std::thread::spawn(move || match point {
FreezePoint::Stop => control.request_stop(),
FreezePoint::Fatal => control.fail(),
});
pause.wait_until_frozen();
assert_eq!(
delivery.accept(),
Ok(()),
"the regression window requires a real internal Accepted CAS"
);
pause.resume_rejection();
interruption.join().expect("interruption does not panic");
assert_eq!(
task.await.expect("producer joined").expect("valid event"),
StrongDecision::Rejected,
"frozen control must override the internal acceptance for the caller"
);
assert_eq!(executions.load(Ordering::Acquire), 0);
assert_eq!(
intent(&source),
if point == FreezePoint::Stop {
TerminalIntent::Stopped
} else {
TerminalIntent::Failed
}
);
assert!(!super::event::testing::has_pending_strong_decision(&source));
}
}
#[tokio::test]
async fn final_confirmation_before_stop_keeps_caller_acceptance_legal() {
let (producer, mut source) = channel(&Token::new());
let mut stream = source.take_stream().expect("stream");
let pause = pause_after_final_confirm(&source);
let executions = Arc::new(AtomicUsize::new(0));
let caller_executions = Arc::clone(&executions);
let task = tokio::spawn(async move {
let outcome = producer
.emit_tool_call(call("confirmed", "tool"), coord())
.await?;
if outcome == StrongDecision::Accepted {
caller_executions.fetch_add(1, Ordering::AcqRel);
}
Ok::<_, ValidationError>(outcome)
});
let delivery = stream.recv().await.expect("pending ToolCall");
delivery.accept().expect("consumer acceptance");
pause.wait_until_confirmed().await;
source.request_stop();
pause.resume_return();
assert_eq!(
task.await.expect("producer joined").expect("valid event"),
StrongDecision::Accepted,
"a stop linearized after final confirmation cannot revoke caller authorization"
);
assert_eq!(executions.load(Ordering::Acquire), 1);
assert_eq!(intent(&source), TerminalIntent::Stopped);
assert!(!super::event::testing::has_pending_strong_decision(&source));
}
#[tokio::test]
async fn fatal_latch_abandons_pending_delivery_before_releasing_the_producer() {
let (producer, mut source) = channel(&Token::new());
let mut stream = source.take_stream().expect("stream");
let task = tokio::spawn(async move {
producer
.emit_tool_result(result("pending", "tool"), coord())
.await
});
let pending = stream.recv().await.expect("pending ToolResult");
fail(&source);
assert_eq!(
task.await.expect("producer joined").expect("valid event"),
StrongDecision::Rejected
);
assert_eq!(pending.accept(), Err(DecisionError::AlreadyDecided));
assert_eq!(pending.reject(), Err(DecisionError::AlreadyDecided));
assert!(!super::event::testing::has_pending_strong_decision(&source));
assert_eq!(intent(&source), TerminalIntent::Failed);
}
#[tokio::test]
async fn graceful_stop_rejects_pending_tool_call_without_canceling_its_own_delivery() {
let parent = Token::new();
let (producer, mut source) = channel(&parent);
let mut stream = source.take_stream().expect("stream");
let executions = Arc::new(AtomicUsize::new(0));
let tool_task = {
let producer = producer.clone();
let executions = executions.clone();
tokio::spawn(async move {
let outcome = producer
.emit_tool_call(call("pending", "tool"), coord())
.await?;
if outcome == StrongDecision::Accepted {
executions.fetch_add(1, Ordering::AcqRel);
}
Ok::<_, ValidationError>(outcome)
})
};
let pending = stream.recv().await.expect("pending tool call");
assert_eq!(pending.event().kind(), Kind::ToolCall);
let stop_task = {
let producer = producer.clone();
tokio::spawn(async move {
producer
.emit_stop(StopCode::new("policy".into()).expect("valid"), coord())
.await
})
};
assert_eq!(
tool_task
.await
.expect("tool join")
.expect("valid tool call"),
StrongDecision::Rejected
);
assert_eq!(
pending.accept(),
Err(DecisionError::AlreadyDecided),
"stop latching rejects the strong seam before tool execution"
);
assert_eq!(pending.reject(), Err(DecisionError::AlreadyDecided));
assert!(!super::event::testing::has_pending_strong_decision(&source));
let stop = stream.recv().await.expect("stop remains deliverable");
assert_eq!(stop.event().kind(), Kind::Stop);
assert_eq!(
stop_task.await.expect("stop join").expect("valid stop"),
DeliveryOutcome::Delivered
);
assert_eq!(executions.load(Ordering::Acquire), 0);
assert_eq!(control(&source), (true, false, false));
assert!(!parent.is_cancelled());
assert_eq!(intent(&source), TerminalIntent::Stopped);
assert_eq!(intent(&source).outcome(), Some(Outcome::Stopped));
assert_eq!(
producer
.emit_text(Kind::Text, "late".into(), coord(), None)
.await
.expect("post-stop emission is rejected, not invalid"),
DeliveryOutcome::Rejected
);
}
#[tokio::test]
async fn stop_is_ordinary_delivery_and_unique_marker_is_exactly_once() {
let (producer, mut source) = channel(&Token::new());
let mut stream = source.take_stream().expect("stream");
let task_producer = producer.clone();
let task = tokio::spawn(async move {
task_producer
.emit_stop(StopCode::new("policy".into()).expect("valid"), coord())
.await
});
let delivery = stream.recv().await.expect("stop");
assert_eq!(delivery.event().kind(), Kind::Stop);
assert_eq!(delivery.decision_point(), None);
assert_eq!(
task.await.expect("join").expect("valid"),
DeliveryOutcome::Delivered
);
assert_eq!(
producer
.emit_stop(StopCode::new("again".into()).expect("valid"), coord())
.await
.expect("valid"),
DeliveryOutcome::Rejected,
);
let next = stream.recv();
tokio::pin!(next);
assert_pending_once(next.as_mut(), "a duplicate Stop must not reach the stream");
}
#[tokio::test]
async fn stream_trait_polls_the_same_unique_receiver() {
let (_producer, mut source) = channel(&Token::new());
let mut stream = source.take_stream().expect("stream");
let mut context = Context::from_waker(Waker::noop());
assert!(matches!(
Pin::new(&mut stream).poll_next(&mut context),
Poll::Pending
));
}
#[test]
fn error_types_implement_standard_error() {
fn assert_error<T: Error>() {}
assert_error::<ValidationError>();
assert_error::<DecisionError>();
for (error, message) in [
(
ValidationError::EmptyAuditKind,
"event audit kind must be non-empty",
),
(
ValidationError::EmptyToolCallId,
"event tool-call identity must be non-empty",
),
(
ValidationError::EmptyToolName,
"event tool name must be non-empty",
),
(
ValidationError::EmptyStopCode,
"event stop code must be non-empty",
),
(
ValidationError::PayloadMismatch,
"event category and payload do not match",
),
(
ValidationError::InvalidDecisionPoint,
"event used an invalid decision point",
),
] {
assert_eq!(error.to_string(), message);
}
assert_eq!(
DecisionError::NotRequired.to_string(),
"event delivery does not require acceptance"
);
assert_eq!(
DecisionError::AlreadyDecided.to_string(),
"event delivery was already decided"
);
}
#[tokio::test]
async fn tool_emitter_authority_is_limited_to_audit_and_error_facts() {
let (producer, mut source) = channel(&Token::new());
let mut stream = source.take_stream().expect("first take owns the stream");
let (emitter, gate) = tool_emitter(&producer, coord());
let audit = tokio::spawn(async move {
emitter
.emit_audit(audit::Event::new("tool.fact".into(), None))
.await
.expect("an open window delivers a valid audit fact");
emitter
.emit_error(Arc::new(FixtureError::ModelBlocked) as Arc<dyn Error + Send + Sync>)
.await
.expect("an open window delivers a degradation notice");
assert_eq!(
emitter
.emit_audit(audit::Event::new(String::new(), None))
.await,
Err(ToolEmitError::Invalid(ValidationError::EmptyAuditKind))
);
emitter
});
let audit_delivery = stream.recv().await.expect("audit is delivered outward");
assert_eq!(audit_delivery.event().kind(), Kind::Audit);
assert_eq!(
audit_delivery.event().as_audit().unwrap().kind(),
"tool.fact"
);
assert_eq!(audit_delivery.event().coord(), Some(&coord()));
assert_eq!(
audit_delivery.decision_point(),
None,
"invocation facts never create a strong-acceptance barrier"
);
drop(audit_delivery);
let error_delivery = stream.recv().await.expect("error is delivered outward");
assert_eq!(error_delivery.event().kind(), Kind::Error);
assert_eq!(error_delivery.event().coord(), Some(&coord()));
drop(error_delivery);
let emitter = audit.await.expect("emitting task completes");
gate.close_and_wait().await;
assert_eq!(
emitter
.emit_audit(audit::Event::new("late".into(), None))
.await,
Err(ToolEmitError::Closed)
);
assert_eq!(
emitter
.emit_error(Arc::new(FixtureError::ModelBlocked) as Arc<dyn Error + Send + Sync>)
.await,
Err(ToolEmitError::Closed)
);
let next = stream.recv();
tokio::pin!(next);
assert_pending_once(
next.as_mut(),
"no further deliveries are produced after closure",
);
}
#[tokio::test]
async fn permanently_closed_tool_emitter_never_reaches_a_producer() {
let emitter = ToolEmitter::closed();
assert_eq!(
emitter
.emit_audit(audit::Event::new("kind".into(), None))
.await,
Err(ToolEmitError::Closed)
);
assert_eq!(
emitter
.emit_error(Arc::new(FixtureError::ModelBlocked) as Arc<dyn Error + Send + Sync>)
.await,
Err(ToolEmitError::Closed)
);
assert_eq!(
emitter
.emit_audit(audit::Event::new(String::new(), None))
.await,
Err(ToolEmitError::Invalid(ValidationError::EmptyAuditKind))
);
}
#[tokio::test]
async fn tool_emitter_reports_non_delivery_when_the_outward_lane_is_gone() {
let (producer, mut source) = channel(&Token::new());
let stream = source.take_stream().expect("first take owns the stream");
let (emitter, _gate) = tool_emitter(&producer, coord());
drop(stream);
assert_eq!(
emitter
.emit_audit(audit::Event::new("after-drop".into(), None))
.await,
Err(ToolEmitError::Rejected)
);
}
#[test]
fn tool_emit_error_displays_are_stable() {
for (error, message) in [
(
ToolEmitError::Closed,
"tool invocation emit window is closed",
),
(
ToolEmitError::Rejected,
"tool invocation event was not delivered",
),
(
ToolEmitError::Invalid(ValidationError::EmptyAuditKind),
"invalid tool invocation event: event audit kind must be non-empty",
),
] {
assert_eq!(error.to_string(), message);
}
fn assert_error<T: Error>() {}
assert_error::<ToolEmitError>();
assert_eq!(
ToolEmitError::Invalid(ValidationError::EmptyAuditKind)
.source()
.and_then(|cause| cause.downcast_ref::<ValidationError>())
.copied(),
Some(ValidationError::EmptyAuditKind)
);
assert!(ToolEmitError::Closed.source().is_none());
assert!(ToolEmitError::Rejected.source().is_none());
}
#[tokio::test]
async fn close_gate_drains_concurrent_in_flight_emissions_before_returning() {
let (producer, mut source) = channel(&Token::new());
let mut stream = source.take_stream().expect("first take owns the stream");
let seam = tokio::spawn({
let producer = producer.clone();
async move {
producer
.emit(
seam_event(DecisionPoint::ToolResult),
Some(DecisionPoint::ToolResult),
)
.await
}
});
let pending_seam = stream.recv().await.expect("the strong seam is delivered");
assert_eq!(
pending_seam.decision_point(),
Some(DecisionPoint::ToolResult)
);
let (emitter, gate) = tool_emitter(&producer, coord());
let emitter = Arc::new(emitter);
let first = tokio::spawn({
let emitter = Arc::clone(&emitter);
async move {
emitter
.emit_audit(audit::Event::new("first".into(), None))
.await
}
});
let second = tokio::spawn({
let emitter = Arc::clone(&emitter);
async move {
emitter
.emit_audit(audit::Event::new("second".into(), None))
.await
}
});
while tool_emitter_active(&emitter) != 2 {
yield_now().await;
}
let mut closing = Box::pin(gate.close_and_wait());
assert_pending_once(
closing.as_mut(),
"closing must not complete while two emissions are still in flight",
);
assert_eq!(
tool_emitter_active(&emitter),
2,
"a closed window still owes its already-active emissions"
);
pending_seam.accept().expect("the seam is still pending");
assert_eq!(
seam.await.expect("join").expect("valid"),
DeliveryOutcome::Accepted
);
let mut drained = Vec::new();
for _ in 0..2 {
let delivery = stream.recv().await.expect("each audit arrives");
drained.push(delivery.event().as_audit().unwrap().kind().to_owned());
}
drained.sort();
assert_eq!(drained, ["first", "second"]);
first
.await
.expect("first task completes")
.expect("delivered");
second
.await
.expect("second task completes")
.expect("delivered");
timeout(Duration::from_secs(5), closing)
.await
.expect("closing completes once every emission drained");
assert_eq!(tool_emitter_active(&emitter), 0);
assert_eq!(
emitter
.emit_audit(audit::Event::new("late".into(), None))
.await,
Err(ToolEmitError::Closed)
);
}
#[tokio::test]
async fn a_cancelled_run_publishes_no_event_of_either_strength() {
let cancellation = Token::new();
let (producer, mut source) = channel(&cancellation);
let mut stream = source.take_stream().expect("one consumer");
cancellation.cancel();
let ordinary = producer
.emit_text(Kind::Text, "unheard".to_owned(), coord(), None)
.await
.expect("a valid text event");
assert_eq!(ordinary, DeliveryOutcome::Rejected);
let strong = producer
.emit_tool_call(call("call-1", "tool"), coord())
.await
.expect("a valid tool call event");
assert_eq!(
strong,
StrongDecision::Cancelled,
"an undelivered strong seam is abandoned rather than left pending"
);
assert!(
!testing::has_pending_strong_decision(&source),
"the abandoned decision is not left registered"
);
let next = stream.recv();
tokio::pin!(next);
assert_pending_once(next.as_mut(), "nothing reached the consumer");
}
#[tokio::test]
async fn a_cancelled_lane_rejects_both_strengths_without_leaving_a_decision() {
let cancellation = Token::new();
let (producer, mut source) = channel(&cancellation);
let _stream = source.take_stream().expect("one consumer");
testing::cancel_lane(&source);
let ordinary = producer
.emit_text(Kind::Text, "unheard".to_owned(), coord(), None)
.await
.expect("a valid text event");
assert_eq!(ordinary, DeliveryOutcome::Rejected);
let strong = producer
.emit_tool_call(call("call-1", "tool"), coord())
.await
.expect("a valid tool call event");
assert_eq!(
strong,
StrongDecision::Rejected,
"an undeliverable strong seam is abandoned rather than left pending"
);
assert!(
!testing::has_pending_strong_decision(&source),
"the abandoned decision is not left registered"
);
}
#[test]
fn event_debug_sizes_model_text_and_flattens_a_third_party_error() {
let location = coord();
let content = text(Kind::Text, SECRET, location.clone());
assert_redacted(&content);
assert_states(
&content,
&["kind: Text", "Text(<21 bytes>)", "coord: Some("],
);
let failure = Event::from_error(Arc::new(FixtureError::ModelBlocked));
assert_states(
&failure,
&[r#"Error("reef: model request blocked")"#, "kind: Error"],
);
let lifecycle_event = lifecycle(Kind::TurnEnd, Some(Outcome::Completed), location.clone());
assert_states(&lifecycle_event, &["Lifecycle(Some(Completed))"]);
let call_event = tool_call(
ToolCall::new(
Id::new("call-1".into()),
tool_call::Name::new("search".into()),
Payload::copy_from_slice(SECRET.as_bytes()),
),
location.clone(),
);
assert_redacted(&call_event);
assert_states(&call_event, &["ToolCall(", "arguments: <21 bytes>"]);
let result_event = tool_result(result("call-1", "search"), location.clone());
assert_redacted(&result_event);
assert_states(&result_event, &["ToolResult(", "NoOutput"]);
let audit_event = Event::from_audit(audit::Event::new(
"progress".into(),
Some(Box::from(*b"ok")),
))
.expect("valid");
assert_states(&audit_event, &[r#"Audit(Event { kind: "progress""#]);
let stop_event = stop(
StopCode::new("done".into()).expect("valid"),
location.clone(),
);
assert_states(&stop_event, &[r#"Stop(StopCode("done"))"#]);
let admitted = input_admitted(
InputOrigin::Mailbox,
vec![Item::User(User::new(
vec![Part::text(SECRET.to_owned())],
ModelVisibility::Visible,
))],
location.clone(),
);
assert_redacted(&admitted);
assert_states(
&admitted,
&[
"kind: InputAdmitted",
"Input(AdmittedInput { origin: Mailbox",
"User(",
],
);
let rejected = input_rejected("out of scope".to_owned(), location);
assert_states(
&rejected,
&["kind: InputRejected", r#"Rejection("out of scope")"#],
);
}
#[tokio::test]
async fn outer_event_and_delivery_never_leak_an_audit_payload() {
let secret = Event::from_audit(audit::Event::new(
"provider.fact".into(),
Some(Box::from(SECRET.as_bytes())),
))
.expect("valid");
assert_redacted(&secret);
assert_states(
&secret,
&["Audit(", r#"kind: "provider.fact""#, "<21 bytes>"],
);
let (producer, mut source) = channel(&Token::new());
let mut stream = source.take_stream().expect("stream");
let task = tokio::spawn(async move { producer.emit(secret, None).await });
let delivery = stream.recv().await.expect("delivery");
assert_redacted(&delivery);
assert_states(&delivery, &["Audit(", "<21 bytes>"]);
assert_eq!(
delivery
.event()
.as_audit()
.and_then(|audit| audit.payload())
.map(<[u8]>::len),
Some(SECRET.len()),
"the payload is still reachable through the accessor, only `Debug` hides it"
);
let _outcome = task.await.expect("join");
}
#[tokio::test]
async fn delivery_and_stream_debug_report_seam_and_fatal_state() {
let (producer, mut source) = channel(&Token::new());
let mut stream = source.take_stream().expect("stream");
assert_eq!(format!("{stream:?}"), "Stream { fatal: false }");
let ordinary = Event::from_audit(audit::Event::new("ordinary".into(), None)).expect("valid");
let task = tokio::spawn(async move { producer.emit(ordinary, None).await });
let delivery = stream.recv().await.expect("delivery");
assert_redacted(&delivery);
assert_states(&delivery, &["decision_point: None", "decision: <absent>"]);
let _outcome = task.await.expect("join");
let (producer, mut source) = channel(&Token::new());
let mut stream = source.take_stream().expect("stream");
let strong = tokio::spawn(async move {
producer
.emit(
seam_event(DecisionPoint::ToolCall),
Some(DecisionPoint::ToolCall),
)
.await
});
let delivery = stream.recv().await.expect("strong delivery");
assert_redacted(&delivery);
assert_states(
&delivery,
&["decision_point: Some(ToolCall)", "decision: <present>"],
);
delivery.accept().expect("accept");
let _outcome = strong.await.expect("join");
}
#[tokio::test]
async fn stream_debug_reports_a_latched_fatal_violation() {
let (producer, mut source) = channel(&Token::new());
let mut stream = source.take_stream().expect("stream");
let task = tokio::spawn(async move {
producer
.emit(
forged(Kind::Audit, text(Kind::Text, "wrong", coord())),
None,
)
.await
});
assert!(
stream.recv().await.is_none(),
"a forged event publishes nothing"
);
let _outcome = task.await.expect("join");
assert_eq!(format!("{stream:?}"), "Stream { fatal: true }");
}
#[test]
fn tool_emitter_debug_is_the_bare_name_and_this_is_the_only_one() {
assert_eq!(format!("{:?}", ToolEmitter::closed()), "ToolEmitter");
assert_eq!(format!("{:#?}", ToolEmitter::closed()), "ToolEmitter");
}
mod kind_tripwire {
use super::super::event::Kind;
macro_rules! kind_tripwire {
($($variant:ident => $tag:literal),+ $(,)?) => {
pub(super) const VARIANTS: &[Kind] = &[$(Kind::$variant),+];
pub(super) const fn tag(kind: Kind) -> &'static str {
match kind {
$(Kind::$variant => $tag,)+
}
}
};
}
kind_tripwire! {
TextDelta => "text_delta",
Text => "text",
ThinkingDelta => "thinking_delta",
Thinking => "thinking",
TurnStart => "turn_start",
TurnEnd => "turn_end",
StepStart => "step_start",
StepEnd => "step_end",
GenerationEnd => "generation_end",
ToolCall => "tool_call",
ToolResult => "tool_result",
Error => "error",
Audit => "audit",
Stop => "stop",
InputAdmitted => "input_admitted",
InputRejected => "input_rejected",
}
#[test]
fn every_kind_variant_has_one_distinct_tag() {
for (position, &kind) in VARIANTS.iter().enumerate() {
let rendered = tag(kind);
assert!(
!rendered.is_empty(),
"a wire tag is never empty: {kind:?} at position {position}"
);
for &other in &VARIANTS[position + 1..] {
assert_ne!(
rendered,
tag(other),
"{kind:?} and {other:?} share the wire tag `{rendered}`"
);
}
}
}
}
#[cfg(feature = "serde")]
mod serde_format {
use super::super::event::Kind;
use super::kind_tripwire::{VARIANTS, tag};
use crate::wire::wire_tests::{assert_expecting, assert_refusal, encode, round_trip};
#[test]
fn every_event_kind_survives_a_round_trip() {
for &kind in VARIANTS {
assert_eq!(encode(&kind), format!("\"{}\"", tag(kind)));
assert_eq!(round_trip(&kind), kind);
}
}
#[test]
fn an_unknown_event_kind_is_refused_rather_than_folded_into_a_wildcard() {
assert_refusal(
serde_json::from_str::<Kind>(r#""interrupted""#),
"unknown variant `interrupted`",
);
assert_expecting::<Kind>("an outward event kind");
}
}