use std::sync::Arc;
use rig_core::completion::Message;
use rig_core::message::{AssistantContent, ToolCall, ToolResult, UserContent};
use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(transparent)]
pub(crate) struct CommittedLog(Vec<Arc<Message>>);
impl CommittedLog {
pub(crate) fn new(prompt: Message) -> Self {
Self(vec![Arc::new(prompt)])
}
pub(crate) fn commit(&mut self, messages: impl IntoIterator<Item = Message>) {
self.0.extend(messages.into_iter().map(Arc::new));
}
pub(crate) fn unstarted_prompt(&mut self) -> Option<&mut Arc<Message>> {
match self.0.as_mut_slice() {
[slot] => Some(slot),
_ => None,
}
}
}
impl std::ops::Deref for CommittedLog {
type Target = [Arc<Message>];
fn deref(&self) -> &[Arc<Message>] {
&self.0
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
#[non_exhaustive]
pub enum CommittedItem<'a> {
ToolCall(&'a ToolCall),
ToolResult(&'a ToolResult),
}
pub fn project(committed: &[Arc<Message>]) -> impl Iterator<Item = CommittedItem<'_>> {
committed.iter().flat_map(|message| {
let (calls, results): (&[AssistantContent], &[UserContent]) = match &**message {
Message::Assistant(assistant) => (&assistant.content, &[]),
Message::User { content } => (&[], content),
Message::System { .. } => (&[], &[]),
};
let calls = calls.iter().filter_map(|item| match item {
AssistantContent::ToolCall(call) => Some(CommittedItem::ToolCall(call)),
_ => None,
});
calls.chain(results.iter().filter_map(|item| match item {
UserContent::ToolResult(result) => Some(CommittedItem::ToolResult(result)),
_ => None,
}))
})
}
#[cfg(test)]
mod tests;