use rap_protocol::ThreadId;
use std::sync::Arc;
use async_trait::async_trait;
use infinity_provider_protocol::{ModelEntry, ModelProvider};
type BoxError = Box<dyn std::error::Error + Send + Sync>;
#[derive(Clone)]
pub struct ResolvedModel {
pub provider: Arc<dyn ModelProvider>,
pub model_id: String,
pub context_window: usize,
pub supports_image_input: bool,
}
#[async_trait(?Send)]
pub trait ModelSource {
async fn resolve(&self, thread_id: &ThreadId<str>) -> Result<ResolvedModel, BoxError>;
}
pub struct StaticModel {
resolved: ResolvedModel,
}
impl StaticModel {
pub async fn new(provider: Arc<dyn ModelProvider>, model_id: &str) -> Result<Self, BoxError> {
let models = provider.list_models().await?;
let entry = models
.into_iter()
.find(|m| m.model_id == model_id)
.ok_or_else(|| format!("model '{model_id}' not found in provider catalog"))?;
Ok(Self::from_entry(provider, &entry))
}
pub fn from_entry(provider: Arc<dyn ModelProvider>, entry: &ModelEntry) -> Self {
Self {
resolved: ResolvedModel {
provider,
model_id: entry.model_id.clone(),
context_window: entry.context_window,
supports_image_input: entry.supports_image_input,
},
}
}
}
#[async_trait(?Send)]
impl ModelSource for StaticModel {
async fn resolve(&self, _thread_id: &ThreadId<str>) -> Result<ResolvedModel, BoxError> {
Ok(self.resolved.clone())
}
}