use std::future::Future;
use std::time::Duration;
use crate::http::{AbortSignal, Body, Read, cancelled, is_aborted, read_chunk};
use crate::types::{AssistantMessage, AssistantMessageEvent, EventSink, StopReason};
pub(crate) const OPERATION_ABORTED: &str = "This operation was aborted";
pub(crate) const REQUEST_WAS_ABORTED: &str = "Request was aborted";
pub(crate) const REQUEST_ABORTED: &str = "Request aborted";
pub(crate) const UNKNOWN_ERROR: &str = "An unknown error occurred";
pub(crate) const OPERATION_TIMED_OUT: &str = "The operation was aborted due to timeout";
pub(crate) trait ProviderError: Sized {
fn plain(message: String) -> Self;
fn aborted() -> Self {
Self::plain(OPERATION_ABORTED.into())
}
}
pub(crate) struct Run<'s, 'e, S> {
pub output: AssistantMessage,
sink: &'s mut EventSink<'e>,
pub state: S,
}
impl<'s, 'e, S> Run<'s, 'e, S> {
pub fn new(output: AssistantMessage, sink: &'s mut EventSink<'e>, state: S) -> Self {
Run { output, sink, state }
}
pub fn emit(&mut self, event: impl FnOnce(AssistantMessage) -> AssistantMessageEvent) {
let event = event(self.output.clone());
(self.sink)(&event);
}
pub fn start(&mut self) {
self.emit(|partial| AssistantMessageEvent::Start { partial });
}
pub fn end(mut self, result: Result<(), String>, signal: Option<&AbortSignal>) -> AssistantMessage {
match result {
Ok(()) => {
let reason = self.output.stop_reason;
self.emit(|message| AssistantMessageEvent::Done { reason, message });
}
Err(error) => {
self.output.stop_reason = if is_aborted(signal) {
StopReason::Aborted
} else {
StopReason::Error
};
self.output.error_message = Some(error);
let reason = self.output.stop_reason;
self.emit(|error| AssistantMessageEvent::Error { reason, error });
}
}
self.output
}
pub fn stopped(&self, signal: Option<&AbortSignal>, pending: &str) -> Result<(), String> {
if is_aborted(signal) {
return Err(REQUEST_WAS_ABORTED.into());
}
match self.output.stop_reason {
StopReason::Pending => Err(pending.into()),
StopReason::Aborted | StopReason::Error => Err(self
.output
.error_message
.clone()
.filter(|m| !m.is_empty())
.unwrap_or_else(|| UNKNOWN_ERROR.into())),
_ => Ok(()),
}
}
}
pub(crate) async fn next_chunk<E: ProviderError>(
body: &mut dyn Body,
signal: Option<&AbortSignal>,
) -> Result<Option<Vec<u8>>, E> {
if is_aborted(signal) {
return Err(E::aborted());
}
match read_chunk(body, signal).await {
Read::Chunk(bytes) => Ok(Some(bytes)),
Read::End => Ok(None),
Read::Aborted => Err(E::aborted()),
Read::Failed(error) => Err(E::plain(error)),
}
}
pub(crate) async fn retry<T, E, Fut>(
signal: Option<&AbortSignal>,
aborted: fn() -> E,
mut send: impl FnMut(u32) -> Fut,
mut classify: impl FnMut(E, u32) -> Result<f64, E>,
) -> Result<T, E>
where
Fut: Future<Output = Result<T, E>>,
{
let mut attempt = 0;
loop {
let error = match send(attempt).await {
Ok(value) => return Ok(value),
Err(error) => error,
};
let delay_ms = classify(error, attempt)?;
tokio::select! {
biased;
() = cancelled(signal) => return Err(aborted()),
() = tokio::time::sleep(delay(delay_ms)) => {}
}
attempt += 1;
}
}
fn delay(ms: f64) -> Duration {
Duration::try_from_secs_f64(ms.max(0.0) / 1000.0).unwrap_or(Duration::from_secs(86_400))
}