some refactoring and docs

noxware · noxware · commit da50450d42de · 2025-02-21T22:28:18.000-03:00
diff --git a/moly-kit/src/clients.rs b/moly-kit/src/clients.rs
@@ -1,3 +1,8 @@
 // TODO: Maybe `json` feature flag can be avoided by using Makepad's microserde.
 #[cfg(feature = "json")]
 pub mod moly;
+pub mod multi;
+
+#[cfg(feature = "json")]
+pub use moly::*;
+pub use multi::*;
diff --git a/moly-kit/src/clients/moly.rs b/moly-kit/src/clients/moly.rs
@@ -12,13 +12,13 @@ use crate::{protocol::*, utils::sse::rsplit_once_terminator};
 
 /// A model from the models endpoint.
 #[derive(Clone, Debug, Deserialize, PartialEq)]
-pub struct Model {
+struct Model {
     id: String,
 }
 
 /// Response from the models endpoint.
 #[derive(Clone, Debug, Deserialize, PartialEq)]
-pub struct Models {
+struct Models {
     pub data: Vec<Model>,
 }
 
@@ -32,15 +32,15 @@ pub struct Models {
 /// And SiliconFlow may set `content` to a `null` value, that's why the custom deserializer
 /// is needed.
 #[derive(Clone, Debug, Deserialize, PartialEq)]
-pub struct IncomingMessage {
+struct IncomingMessage {
     #[serde(default)]
     #[serde(deserialize_with = "deserialize_null_default")]
     pub content: String,
 }
 
 /// A message being sent to the completions endpoint.
 #[derive(Clone, Debug, Serialize)]
-pub struct OutcomingMessage {
+struct OutcomingMessage {
     pub content: String,
     pub role: Role,
 }
@@ -65,7 +65,7 @@ impl TryFrom<Message> for OutcomingMessage {
 
 /// Role of a message that is part of the conversation context.
 #[derive(Clone, Debug, Serialize, Deserialize)]
-pub enum Role {
+enum Role {
     /// OpenAI o1 models seems to expect `developer` instead of `system` according
     /// to the documentation. But it also seems like `system` is converted to `developer`
     /// internally.
@@ -78,13 +78,13 @@ pub enum Role {
 }
 
 #[derive(Clone, Debug, Deserialize)]
-pub struct Choice {
+struct Choice {
     pub delta: IncomingMessage,
 }
 
 /// Response from the completions endpoint.
 #[derive(Clone, Debug, Deserialize)]
-pub struct Completation {
+struct Completation {
     pub choices: Vec<Choice>,
 }
 
@@ -94,6 +94,7 @@ struct MolyClientInner {
     headers: HeaderMap,
 }
 
+/// A client capable of interacting with Moly Server and other OpenAI-compatible APIs.
 #[derive(Debug)]
 pub struct MolyClient(Arc<Mutex<MolyClientInner>>);
 
@@ -110,6 +111,7 @@ impl From<MolyClientInner> for MolyClient {
 }
 
 impl MolyClient {
+    /// Creates a new client with the given OpenAI-compatible API URL.
     pub fn new(url: String) -> Self {
         let mut headers = HeaderMap::new();
         headers.insert("Content-Type", "application/json".parse().unwrap());
diff --git a/moly-kit/src/clients/multi.rs b/moly-kit/src/clients/multi.rs
@@ -0,0 +1,87 @@
+use crate::protocol::*;
+pub use crate::utils::asynchronous::{moly_future, moly_stream, MolyFuture, MolyStream};
+use std::sync::{Arc, Mutex};
+
+/// A client that can be composed from multiple subclients to interact with all of them as one.
+#[derive(Clone)]
+pub struct MultiClient {
+    clients_with_bots: Arc<Mutex<Vec<(Box<dyn BotClient>, Vec<Bot>)>>>,
+}
+
+impl MultiClient {
+    pub fn new() -> Self {
+        MultiClient {
+            clients_with_bots: Arc::new(Mutex::new(Vec::new())),
+        }
+    }
+
+    pub fn add_client(&mut self, client: Box<dyn BotClient>) {
+        self.clients_with_bots
+            .lock()
+            .unwrap()
+            .push((client, Vec::new()));
+    }
+}
+
+impl BotClient for MultiClient {
+    fn send_stream(
+        &mut self,
+        bot: &BotId,
+        messages: &[Message],
+    ) -> MolyStream<'static, Result<String, ()>> {
+        let mut client = self
+            .clients_with_bots
+            .lock()
+            .unwrap()
+            .iter()
+            .find_map(|(client, bots)| {
+                if bots.iter().any(|b| b.id == *bot) {
+                    Some(client.clone())
+                } else {
+                    None
+                }
+            })
+            .expect("no client for bot");
+
+        client.send_stream(&bot, messages)
+    }
+
+    fn clone_box(&self) -> Box<dyn BotClient> {
+        Box::new(self.clone())
+    }
+
+    fn bots(&self) -> MolyFuture<'static, Result<Vec<Bot>, ()>> {
+        let clients_with_bots = self.clients_with_bots.clone();
+
+        let future = async move {
+            let clients = clients_with_bots
+                .lock()
+                .unwrap()
+                .iter()
+                .map(|(client, _)| client.clone())
+                .collect::<Vec<_>>();
+
+            let bot_futures = clients.iter().map(|client| client.bots());
+            let results = futures::future::join_all(bot_futures).await;
+
+            let mut zipped_bots = Vec::new();
+            let mut flat_bots = Vec::new();
+
+            for result in results {
+                // TODO: Let's ignore any errored sub-client for now.
+                let client_bots = result.unwrap_or_default();
+                zipped_bots.push(client_bots.clone());
+                flat_bots.extend(client_bots);
+            }
+
+            *clients_with_bots.lock().unwrap() = clients
+                .into_iter()
+                .zip(zipped_bots.iter().cloned())
+                .collect();
+
+            Ok(flat_bots)
+        };
+
+        moly_future(future)
+    }
+}
diff --git a/moly-kit/src/lib.rs b/moly-kit/src/lib.rs
@@ -58,5 +58,6 @@ pub mod protocol;
 pub mod utils;
 pub mod widgets;
 
+pub use clients::*;
 pub use protocol::*;
 pub use widgets::*;
diff --git a/moly-kit/src/protocol.rs b/moly-kit/src/protocol.rs
@@ -78,7 +78,7 @@ pub struct Message {
     pub is_writing: bool,
 }
 
-/// An interface to talk to bots.
+/// A standard interface to fetch bots information and send messages to them.
 ///
 /// Warning: Expect this to be cloned to avoid borrow checking issues with
 /// makepad's widgets. Also, it may be cloned inside async contexts. So keep this
@@ -144,6 +144,13 @@ struct InnerBotRepo {
     bots: Vec<Bot>,
 }
 
+/// A sharable wrapper around a [BotClient] that holds loadeed bots and provides
+/// synchronous APIs to access them, mainly from the UI.
+///
+/// Passed down through widgets from this crate.
+///
+/// Separate chat widgets can share the same [BotRepo] to avoid loading the same
+/// bots multiple times.
 pub struct BotRepo(Arc<Mutex<InnerBotRepo>>);
 
 impl Clone for BotRepo {
@@ -197,86 +204,3 @@ impl<T: BotClient + 'static> From<T> for BotRepo {
         })))
     }
 }
-
-#[derive(Clone)]
-pub struct MultiBotClient {
-    clients_with_bots: Arc<Mutex<Vec<(Box<dyn BotClient>, Vec<Bot>)>>>,
-}
-
-impl MultiBotClient {
-    pub fn new() -> Self {
-        MultiBotClient {
-            clients_with_bots: Arc::new(Mutex::new(Vec::new())),
-        }
-    }
-
-    pub fn add_client(&mut self, client: Box<dyn BotClient>) {
-        self.clients_with_bots
-            .lock()
-            .unwrap()
-            .push((client, Vec::new()));
-    }
-}
-
-impl BotClient for MultiBotClient {
-    fn send_stream(
-        &mut self,
-        bot: &BotId,
-        messages: &[Message],
-    ) -> MolyStream<'static, Result<String, ()>> {
-        let mut client = self
-            .clients_with_bots
-            .lock()
-            .unwrap()
-            .iter()
-            .find_map(|(client, bots)| {
-                if bots.iter().any(|b| b.id == *bot) {
-                    Some(client.clone())
-                } else {
-                    None
-                }
-            })
-            .expect("no client for bot");
-
-        client.send_stream(&bot, messages)
-    }
-
-    fn clone_box(&self) -> Box<dyn BotClient> {
-        Box::new(self.clone())
-    }
-
-    fn bots(&self) -> MolyFuture<'static, Result<Vec<Bot>, ()>> {
-        let clients_with_bots = self.clients_with_bots.clone();
-
-        let future = async move {
-            let clients = clients_with_bots
-                .lock()
-                .unwrap()
-                .iter()
-                .map(|(client, _)| client.clone())
-                .collect::<Vec<_>>();
-
-            let bot_futures = clients.iter().map(|client| client.bots());
-            let results = futures::future::join_all(bot_futures).await;
-
-            let mut zipped_bots = Vec::new();
-            let mut flat_bots = Vec::new();
-
-            for result in results {
-                // TODO: Let's ignore any errored sub-client for now.
-                let client_bots = result.unwrap_or_default();
-                zipped_bots.push(client_bots.clone());
-                flat_bots.extend(client_bots);
-            }
-
-            *clients_with_bots.lock().unwrap() = clients
-                .into_iter()
-                .zip(zipped_bots.iter().cloned())
-                .collect();
-
-            Ok(flat_bots)
-        };
-
-        moly_future(future)
-    }
-}
diff --git a/moly-mini/src/demo_chat.rs b/moly-mini/src/demo_chat.rs
@@ -1,7 +1,6 @@
 use makepad_widgets::*;
-use moly_kit::clients::moly::*;
 use moly_kit::utils::asynchronous::spawn;
-use moly_kit::{protocol::*, ChatTask, ChatWidgetExt};
+use moly_kit::*;
 
 use crate::bot_selector::BotSelectorWidgetExt;
 
@@ -73,7 +72,7 @@ impl Widget for DemoChat {
                 let mut openai = MolyClient::new(openai_url.into());
                 openai.set_key(OPEN_AI_KEY.unwrap_or(""));
 
-                let mut client = MultiBotClient::new();
+                let mut client = MultiClient::new();
                 client.add_client(Box::new(moly));
                 client.add_client(Box::new(ollama));
                 client.add_client(Box::new(openai));
