use std::sync::Arc;
pub use ai::overflow::is_context_overflow;
use ai::{AssistantMessage, AssistantMessageEvent, DeferredHandle, Model, TranscriptContext};
use serde::{Deserialize, Serialize};
use serde_json::{Map, Value};
use super::inbox::{QueueMode, QueueModes};
use crate::scheduler::{Cancel, HarnessError, Result};
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ModelRef {
pub provider: String,
pub model_id: String,
}
impl ModelRef {
pub fn new(provider: &str, model_id: &str) -> ModelRef {
ModelRef {
provider: provider.to_owned(),
model_id: model_id.to_owned(),
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct StreamRequest {
pub options: Map<String, Value>,
pub session_id: Option<String>,
pub reasoning: Option<String>,
pub conversation_id: Option<durable::ConversationId>,
pub final_note: Option<String>,
}
impl StreamRequest {
pub fn simple_options(&self) -> ai::SimpleStreamOptions {
let mut options: ai::SimpleStreamOptions =
serde_json::from_value(Value::Object(self.options.clone())).unwrap_or_default();
options.base.session_id = self.session_id.clone();
options.reasoning = self.reasoning.clone();
options
}
}
pub trait Models: Send + Sync {
fn get_model(&self, provider: &str, model_id: &str) -> Option<Model>;
fn stream(
&self,
model: &Model,
context: &TranscriptContext,
request: &StreamRequest,
signal: &Cancel,
on_event: &mut (dyn FnMut(&AssistantMessageEvent) + Send),
) -> Result<AssistantMessage>;
fn fetch_deferred(&self, model: &Model, handle: &DeferredHandle, signal: &Cancel) -> Result<AssistantMessage> {
let _ = (model, handle, signal);
Err(HarnessError::msg("This provider has no deferred responses"))
}
fn cancel_deferred(&self, model: &Model, handle: &DeferredHandle, signal: &Cancel) -> Result<()> {
let _ = (model, handle, signal);
Ok(())
}
}
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct CompactionPolicy {
pub enabled: bool,
pub reserve_tokens: u64,
pub keep_recent_tokens: u64,
pub background_tokens: u64,
}
impl Default for CompactionPolicy {
fn default() -> Self {
CompactionPolicy {
enabled: true,
reserve_tokens: 16_384,
keep_recent_tokens: 20_000,
background_tokens: 32_768,
}
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub enum ToolExecution {
#[default]
Parallel,
Sequential,
}
#[derive(Clone, Debug, PartialEq)]
pub struct Settings {
pub stream: Map<String, Value>,
pub retry: ai::retry::RetryPolicy,
pub compaction: CompactionPolicy,
pub partial_interval_ms: u64,
pub output_interval_ms: u64,
pub tool_execution: ToolExecution,
pub steering_mode: QueueMode,
pub follow_up_mode: QueueMode,
pub follow_up_after_steer: bool,
}
impl Default for Settings {
fn default() -> Self {
Settings {
stream: Map::new(),
retry: ai::retry::RetryPolicy::default(),
compaction: CompactionPolicy::default(),
partial_interval_ms: 100,
output_interval_ms: 100,
tool_execution: ToolExecution::Parallel,
steering_mode: QueueMode::OneAtATime,
follow_up_mode: QueueMode::OneAtATime,
follow_up_after_steer: false,
}
}
}
impl Settings {
pub(crate) fn queue_modes(&self) -> QueueModes {
QueueModes {
steering: self.steering_mode,
follow_up: self.follow_up_mode,
follow_up_after_steer: self.follow_up_after_steer,
}
}
}
pub type SettingsSource = Arc<dyn Fn() -> Settings + Send + Sync>;