pub mod interactive;
pub mod print;
pub mod stream_json;
use futures::StreamExt;
use tokio_util::sync::CancellationToken;
use pixie_pi::agent::context::AgentEvent;
use pixie_pi::session::AgentSession;
pub struct RunOutcome {
pub final_messages: Option<Vec<pixie_pi::ai::Message>>,
pub last_usage: Option<pixie_pi::ai::Usage>,
pub had_error: bool,
}
pub async fn drive<F>(session: &mut AgentSession, prompts: Vec<pixie_pi::ai::Message>, mut on_event: F) -> RunOutcome
where
F: FnMut(&AgentEvent) -> bool,
{
let cancel = CancellationToken::new();
let cc = cancel.clone();
let ctrl_task = tokio::spawn(async move {
if tokio::signal::ctrl_c().await.is_ok() {
cc.cancel();
}
});
if session.should_compact() {
let dropped = session.compact().await;
if dropped > 0 {
eprintln!(
"{}",
crate::render::dim(&format!(
" ↳ context near limit: compacted {dropped} message(s)"
))
);
}
}
let mut stream = session.run(prompts, cancel);
let mut outcome = RunOutcome {
final_messages: None,
last_usage: None,
had_error: false,
};
while let Some(ev) = stream.next().await {
match &ev {
AgentEvent::Usage(u) => record_turn_usage(session, &mut outcome.last_usage, u),
AgentEvent::AgentEnd { messages } => outcome.final_messages = Some(messages.clone()),
AgentEvent::Error(_) => outcome.had_error = true,
AgentEvent::TurnEnd { message, .. } => {
use pixie_pi::ai::types::StopReason;
if matches!(
message.stop_reason,
StopReason::Error | StopReason::Aborted
) || message.error_message.is_some()
{
outcome.had_error = true;
}
}
_ => {}
}
let stop = on_event(&ev);
if stop {
break;
}
}
ctrl_task.abort();
if let Some(msgs) = outcome.final_messages.take() {
session.messages = msgs;
}
let _ = session.save();
outcome
}
fn record_turn_usage(session: &mut AgentSession, last: &mut Option<pixie_pi::ai::Usage>, u: &pixie_pi::ai::Usage) {
session.add_usage(u);
*last = Some(u.clone());
}
#[cfg(test)]
mod tests {
use super::*;
use pixie_pi::ai::types::Usage;
fn test_session() -> AgentSession {
let model = pixie_pi::ai::builtin_models()[0].clone();
AgentSession::new(
std::path::PathBuf::from("."),
"sys".into(),
model,
pixie_pi::ai::ThinkingLevel::Off,
vec![],
reqwest::Client::new(),
)
}
#[test]
fn record_turn_usage_sums_every_turn_not_just_the_last() {
let mut session = test_session();
let mut last = None;
let turn = |input, output| Usage {
input,
output,
..Usage::default()
};
record_turn_usage(&mut session, &mut last, &turn(100, 50));
record_turn_usage(&mut session, &mut last, &turn(200, 10));
record_turn_usage(&mut session, &mut last, &turn(0, 5));
assert_eq!(session.total_usage.input, 300, "input must sum all turns");
assert_eq!(session.total_usage.output, 65, "output must sum all turns");
assert_eq!(
last.as_ref().unwrap().output,
5,
"`last` still remembers the most recent turn"
);
}
}