use bunsen::{
errors::{
BunsenError,
BunsenResult,
},
kits::support::tokens::Tokenizer,
};
use crate::chat::ChatMessage;
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct NanoChatLayout {
pub bos: i64,
pub user_start: i64,
pub user_end: i64,
pub assistant_start: i64,
pub assistant_end: i64,
}
impl NanoChatLayout {
pub fn from_tokenizer(tokenizer: &dyn Tokenizer) -> BunsenResult<Self> {
let special = |name: &str| {
tokenizer.token_id(name).ok_or_else(|| {
BunsenError::invalid_resource(format!("a nanochat tokenizer without {name}"))
})
};
Ok(Self {
bos: special("<|bos|>")?,
user_start: special("<|user_start|>")?,
user_end: special("<|user_end|>")?,
assistant_start: special("<|assistant_start|>")?,
assistant_end: special("<|assistant_end|>")?,
})
}
pub fn stop_ids(&self) -> Vec<i64> {
vec![self.assistant_end, self.bos]
}
pub fn render(
&self,
tokenizer: &dyn Tokenizer,
messages: &[ChatMessage],
) -> BunsenResult<Vec<i64>> {
let folded;
let messages = match messages {
[system, user, rest @ ..] if system.role == "system" => {
if user.role != "user" {
return Err(BunsenError::illegal(
"a nanochat conversation's system message must be followed by a user's",
));
}
folded = std::iter::once(ChatMessage::user(format!(
"{}\n\n{}",
system.content, user.content
)))
.chain(rest.iter().cloned())
.collect::<Vec<_>>();
folded.as_slice()
}
[system] if system.role == "system" => {
return Err(BunsenError::illegal(
"a nanochat conversation's system message must be followed by a user's",
));
}
_ => messages,
};
match messages.last() {
None => return Err(BunsenError::illegal("an empty nanochat conversation")),
Some(last) if last.role != "user" => {
return Err(BunsenError::illegal(
"a nanochat conversation to reply to ends with a user's turn",
));
}
Some(_) => {}
}
let mut ids = vec![self.bos];
for (i, message) in messages.iter().enumerate() {
let (role, start, end) = if i % 2 == 0 {
("user", self.user_start, self.user_end)
} else {
("assistant", self.assistant_start, self.assistant_end)
};
if message.role != role {
return Err(BunsenError::illegal(format!(
"a nanochat conversation's turn {i} is the {}'s, where it alternates to the {role}'s",
message.role
)));
}
ids.push(start);
ids.extend(tokenizer.encode_plain(&message.content)?);
ids.push(end);
}
ids.push(self.assistant_start);
Ok(ids)
}
}
#[cfg(test)]
mod tests {
use bunsen::{
errors::{
BunsenErrorKind,
testing::ErrorMatcher,
},
kits::support::tokens::{
BunsenTokenizer,
testing::toy_tiktoken_pickle,
},
};
use super::*;
fn toy() -> (BunsenTokenizer, NanoChatLayout) {
let tok = BunsenTokenizer::from_tiktoken_pickle(&toy_tiktoken_pickle()).unwrap();
let layout = NanoChatLayout::from_tokenizer(&tok).unwrap();
(tok, layout)
}
#[test]
fn test_render() {
let (tok, layout) = toy();
assert_eq!(layout.stop_ids(), [264, 260]);
let hello = 259;
let ids = layout
.render(
&tok,
&[
ChatMessage::user("hello"),
ChatMessage::assistant("hello"),
ChatMessage::user("hello"),
],
)
.unwrap();
assert_eq!(
ids,
[260, 261, hello, 262, 263, hello, 264, 261, hello, 262, 263]
);
}
#[test]
fn test_system_message_folds_into_the_first_turn() {
let (tok, layout) = toy();
let folded = layout
.render(
&tok,
&[ChatMessage::system("hello"), ChatMessage::user("hello")],
)
.unwrap();
let joined = layout
.render(&tok, &[ChatMessage::user("hello\n\nhello")])
.unwrap();
assert_eq!(folded, joined);
}
#[test]
fn test_refuses_what_upstream_cannot_render() {
let (tok, layout) = toy();
let illegal = ErrorMatcher::kind(BunsenErrorKind::Illegal);
illegal.assert_err(&layout.render(&tok, &[]));
illegal.assert_err(&layout.render(&tok, &[ChatMessage::system("hello")]));
illegal.assert_err(&layout.render(&tok, &[ChatMessage::assistant("hello")]));
illegal.assert_err(&layout.render(
&tok,
&[ChatMessage::user("hello"), ChatMessage::assistant("hello")],
));
illegal.assert_err(&layout.render(
&tok,
&[ChatMessage::user("hello"), ChatMessage::user("hello")],
));
}
}