use std::sync::Arc;
use rig_core::completion::Document;
use rig_core::message::{Message, ToolChoice};
use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RequestPatch {
pub preamble: Option<String>,
pub temperature: Option<f64>,
pub max_tokens: Option<u64>,
pub tool_choice: Option<ToolChoice>,
pub active_tools: Option<Vec<String>>,
pub additional_params: Option<serde_json::Value>,
pub extra_context: Vec<Document>,
pub history: Option<Vec<Arc<Message>>>,
}
fn merge_last_wins<T>(earlier: Option<T>, later: Option<T>, field: &str) -> Option<T> {
match (earlier, later) {
(Some(_), Some(later)) => {
tracing::warn!(
patch_field = field,
"two hooks set the same request field; later wins"
);
Some(later)
}
(earlier, later) => later.or(earlier),
}
}
pub(crate) fn overlay_params(
base: Option<serde_json::Value>,
later: Option<serde_json::Value>,
) -> Option<serde_json::Value> {
match (base, later) {
(Some(base), Some(later)) if base.is_object() && later.is_object() => {
Some(rig_core::json_utils::merge(base, later))
}
(base, later) => later.or(base),
}
}
impl RequestPatch {
pub fn new() -> Self {
Self::default()
}
pub fn preamble(mut self, value: impl Into<String>) -> Self {
self.preamble = Some(value.into());
self
}
pub fn temperature(mut self, value: f64) -> Self {
self.temperature = Some(value);
self
}
pub fn max_tokens(mut self, value: u64) -> Self {
self.max_tokens = Some(value);
self
}
pub fn tool_choice(mut self, value: ToolChoice) -> Self {
self.tool_choice = Some(value);
self
}
pub fn active_tools<I, S>(mut self, values: I) -> Self
where
I: IntoIterator<Item = S>,
S: Into<String>,
{
self.active_tools = Some(values.into_iter().map(Into::into).collect());
self
}
pub fn additional_params(mut self, value: serde_json::Value) -> Self {
self.additional_params = Some(value);
self
}
pub fn extra_context<I>(mut self, values: I) -> Self
where
I: IntoIterator<Item = Document>,
{
self.extra_context.extend(values);
self
}
pub fn context(mut self, value: Document) -> Self {
self.extra_context.push(value);
self
}
pub fn history<I>(mut self, values: I) -> Self
where
I: IntoIterator<Item: Into<Arc<Message>>>,
{
self.history = Some(values.into_iter().map(Into::into).collect());
self
}
pub fn is_empty(&self) -> bool {
*self == Self::default()
}
pub fn merge(mut self, later: Self) -> Self {
self.extra_context.extend(later.extra_context);
self.additional_params =
overlay_params(self.additional_params.take(), later.additional_params);
self.preamble = merge_last_wins(self.preamble, later.preamble, "preamble");
self.temperature = merge_last_wins(self.temperature, later.temperature, "temperature");
self.max_tokens = merge_last_wins(self.max_tokens, later.max_tokens, "max_tokens");
self.tool_choice = merge_last_wins(self.tool_choice, later.tool_choice, "tool_choice");
self.history = merge_last_wins(self.history, later.history, "history");
self.active_tools = match (self.active_tools.take(), later.active_tools) {
(Some(earlier), Some(later)) => {
let later: std::collections::BTreeSet<_> = later.iter().collect();
Some(
earlier
.into_iter()
.filter(|name| later.contains(name))
.collect(),
)
}
(earlier, later) => earlier.or(later),
};
self
}
}
#[cfg(test)]
mod tests;