use crate::{
DevinChatRequest, DevinError, DevinEventStream, DevinLoginOptions, DevinModel,
DevinProviderOptions, ListDevinModelsOptions, StreamDevinChatOptions, TokenStoreRef,
create_memory_token_store, fetch::default_fetch, list_devin_models, login_devin,
stream_devin_chat,
};
use std::sync::Arc;
use tokio::sync::Mutex;
#[derive(Default)]
struct ModelCatalog {
token: Option<String>,
models: Vec<DevinModel>,
}
#[derive(Clone)]
pub struct DevinProvider {
token_store: TokenStoreRef,
options: DevinProviderOptions,
catalog: Arc<Mutex<ModelCatalog>>,
}
pub fn create_devin_provider(options: DevinProviderOptions) -> DevinProvider {
DevinProvider {
token_store: options
.token_store
.clone()
.unwrap_or_else(|| create_memory_token_store(None)),
options,
catalog: Arc::new(Mutex::new(ModelCatalog::default())),
}
}
impl DevinProvider {
pub async fn login(&self) -> Result<String, DevinError> {
let token = login_devin(DevinLoginOptions {
fetch: self.options.fetch.clone(),
open_browser: self.options.open_browser.clone(),
app_base_url: self.options.app_base_url.clone(),
auth_base_url: self.options.auth_base_url.clone(),
})
.await?;
self.token_store.set(token.clone()).await?;
*self.catalog.lock().await = ModelCatalog::default();
Ok(token)
}
pub async fn set_token(&self, token: impl Into<String>) -> Result<(), DevinError> {
self.token_store.set(token.into()).await?;
*self.catalog.lock().await = ModelCatalog::default();
Ok(())
}
pub async fn clear_token(&self) -> Result<(), DevinError> {
self.token_store.clear().await?;
*self.catalog.lock().await = ModelCatalog::default();
Ok(())
}
pub async fn list_models(&self) -> Result<Vec<DevinModel>, DevinError> {
let token = self.token_store.get().await?;
let models = list_devin_models(ListDevinModelsOptions {
token: token.clone(),
base_url: self.options.base_url.clone(),
fetch: Some(self.options.fetch.clone().unwrap_or_else(default_fetch)),
client_metadata: self.options.client_metadata.clone(),
})
.await?;
*self.catalog.lock().await = ModelCatalog {
token,
models: models.clone(),
};
Ok(models)
}
pub fn stream_chat(&self, mut request: DevinChatRequest) -> DevinEventStream {
let store = self.token_store.clone();
let base_url = self.options.base_url.clone();
let fetch = self.options.fetch.clone().unwrap_or_else(default_fetch);
let uuid = self.options.uuid.clone();
let client_metadata = self.options.client_metadata.clone();
let catalog = self.catalog.clone();
Box::pin(async_stream::try_stream! {
let token = store.get().await?;
if request.model_config.is_none() {
let catalog = catalog.lock().await;
if token == catalog.token { request.model_config = catalog.models.iter().find(|model| model.id == request.model).cloned(); }
}
let stream = stream_devin_chat(StreamDevinChatOptions::from_request(
request,
token,
base_url,
fetch,
uuid,
client_metadata,
));
futures_util::pin_mut!(stream);
while let Some(event) = futures_util::StreamExt::next(&mut stream).await {
yield event?;
}
})
}
}