feat: support multi models

Author: zensh

agents/anda_assistant/Cargo.toml

@@ -3,7 +3,7 @@ name = "anda_assistant"
 description = "Anda -- an AI Assistant powered by the Knowledge Interaction Protocol (KIP)."
 repository = "https://github.com/ldclabs/anda/tree/main/agents/anda_assistant"
 publish = true
-version = "0.4.0"
+version = "0.4.1"
 edition.workspace = true
 keywords.workspace = true
 categories.workspace = true

agents/anda_assistant/src/agent.rs

@@ -1,8 +1,7 @@
 use anda_cognitive_nexus::{CognitiveNexus, ConceptPK};
 use anda_core::{
-    Agent, AgentContext, AgentOutput, BoxError, CompletionRequest, Document, Documents,
-    Message, Principal, Resource, StateFeatures, Tool, ToolSet, Usage, evaluate_tokens,
-    update_resources,
+    Agent, AgentContext, AgentOutput, BoxError, CompletionRequest, Document, Documents, Message,
+    Principal, Resource, StateFeatures, Tool, ToolSet, Usage, evaluate_tokens, update_resources,
 };
 use anda_db::{database::AndaDB, index::BTree};
 use anda_engine::{
@@ -219,14 +218,36 @@ impl Agent<AgentCtx> for Assistant {
             ((evaluate_tokens(&instructions) + evaluate_tokens(&prompt)) as f64 * 1.2) as usize,
         ) * 3; // Rough estimate of bytes per token
         let mut writer: Vec<u8> = Vec::with_capacity(256);
-        let _ = serde_json::to_writer(&mut writer, &conversations);
-        let mut history_bytes = writer.len();
+        let mut history_bytes = if serde_json::to_writer(&mut writer, &conversations).is_ok() {
+            writer.len()
+        } else {
+            0
+        };
+
+        // Keep the most recent conversations; remove the oldest first.
         while history_bytes > max_history_bytes && !conversations.is_empty() {
+            let oldest_idx = conversations
+                .iter()
+                .enumerate()
+                .min_by_key(|(_, c)| c.created_at)
+                .map(|(idx, _)| idx)
+                .unwrap_or(0);
+
             writer.clear();
-            let conv = conversations.remove(0);
-            cursor = BTree::to_cursor(&conv._id);
-            let _ = serde_json::to_writer(&mut writer, &conv);
-            history_bytes = history_bytes.saturating_sub(writer.len());
+            if serde_json::to_writer(&mut writer, &conversations[oldest_idx]).is_ok() {
+                history_bytes = history_bytes.saturating_sub(writer.len());
+            } else {
+                break;
+            }
+
+            conversations.remove(oldest_idx);
+        }
+
+        // Cursor should allow listing conversations older than the oldest one we kept.
+        if !conversations.is_empty()
+            && let Some(min_id) = conversations.iter().map(|c| c._id).min()
+        {
+            cursor = BTree::to_cursor(&min_id);
         }
 
         let mut history_docs: Vec<Document> = Vec::with_capacity(conversations.len() + 2);
@@ -257,7 +278,7 @@ impl Agent<AgentCtx> for Assistant {
             content: vec![
                 format!(
                     "Current Datetime: {}\n---\n{}",
-                    rfc3339_datetime(created_at).unwrap(),
+                    rfc3339_datetime(created_at).unwrap_or_else(|| format!("unix_ms:{created_at}")),
                     Documents::new("history".to_string(), history_docs)
                 )
                 .into(),
@@ -334,8 +355,16 @@ impl Agent<AgentCtx> for Assistant {
                                 conversation.messages.clear(); // clear the first pending message.
                                 conversation.append_messages(res.chat_history);
                             } else {
-                                res.chat_history.drain(0..conversation.messages.len());
-                                conversation.append_messages(res.chat_history);
+                                let existing_len = conversation.messages.len();
+                                if res.chat_history.len() >= existing_len {
+                                    res.chat_history.drain(0..existing_len);
+                                    conversation.append_messages(res.chat_history);
+                                } else {
+                                    // Unexpected: runner returned shorter full history.
+                                    // Fall back to replacing stored messages.
+                                    conversation.messages.clear();
+                                    conversation.append_messages(res.chat_history);
+                                }
                             }
 
                             conversation.artifacts = artifacts;

agents/anda_bot/Cargo.toml

@@ -37,5 +37,5 @@ hex = { workspace = true }
 
 [dev-dependencies]
 
-[patch.crates-io]
-candid = { git = "https://github.com/ldclabs/candid.git", rev = "4cf7d02bad9530172cb4cafe733cb1e80689b793" } # remove check_recursion on stack for TEE
+# [patch.crates-io]
+# candid = { git = "https://github.com/ldclabs/candid.git", rev = "4cf7d02bad9530172cb4cafe733cb1e80689b793" } # remove check_recursion on stack for TEE

agents/anda_nexus/Cargo.toml

@@ -3,7 +3,7 @@ name = "anda_nexus"
 description = "Anda -- an AI Nexus powered by the Knowledge Interaction Protocol (KIP)."
 repository = "https://github.com/ldclabs/anda/tree/main/agents/anda_nexus"
 publish = true
-version = "0.2.0"
+version = "0.2.1"
 edition.workspace = true
 keywords.workspace = true
 categories.workspace = true

agents/anda_nexus/src/bin/main.rs

@@ -135,7 +135,7 @@ async fn main() -> Result<(), BoxError> {
             visibility: Visibility::Public,
         }))
         .register_tools(tools)?
-        .register_agent(agent)?
+        .register_agent(agent, None)?
         .export_tools(tools_name);
 
     // Initialize and start the server

anda_core/src/agent.rs

@@ -144,6 +144,8 @@ pub trait AgentDyn<C>: Send + Sync
 where
     C: AgentContext + Send + Sync,
 {
+    fn label(&self) -> &str;
+
     fn name(&self) -> String;
 
     fn definition(&self) -> FunctionDefinition;
@@ -163,34 +165,43 @@ where
 }
 
 /// Adapter for converting static Agent to dynamic dispatch.
-struct AgentWrapper<T, C>(Arc<T>, PhantomData<C>)
+struct AgentWrapper<T, C>
 where
     T: Agent<C> + 'static,
-    C: AgentContext + Send + Sync + 'static;
+    C: AgentContext + Send + Sync + 'static,
+{
+    inner: Arc<T>,
+    label: String,
+    _phantom: PhantomData<C>,
+}
 
 impl<T, C> AgentDyn<C> for AgentWrapper<T, C>
 where
     T: Agent<C> + 'static,
     C: AgentContext + Send + Sync + 'static,
 {
+    fn label(&self) -> &str {
+        &self.label
+    }
+
     fn name(&self) -> String {
-        self.0.name()
+        self.inner.name()
     }
 
     fn definition(&self) -> FunctionDefinition {
-        self.0.definition()
+        self.inner.definition()
     }
 
     fn tool_dependencies(&self) -> Vec<String> {
-        self.0.tool_dependencies()
+        self.inner.tool_dependencies()
     }
 
     fn supported_resource_tags(&self) -> Vec<String> {
-        self.0.supported_resource_tags()
+        self.inner.supported_resource_tags()
     }
 
     fn init(&self, ctx: C) -> BoxPinFut<Result<(), BoxError>> {
-        let agent = self.0.clone();
+        let agent = self.inner.clone();
         Box::pin(async move { agent.init(ctx).await })
     }
 
@@ -200,7 +211,7 @@ where
         prompt: String,
         resources: Vec<Resource>,
     ) -> BoxPinFut<Result<AgentOutput, BoxError>> {
-        let agent = self.0.clone();
+        let agent = self.inner.clone();
         Box::pin(async move { agent.run(ctx, prompt, resources).await })
     }
 }
@@ -275,11 +286,13 @@ where
     /// # Returns
     /// - Vec<[`Function`]>: Vector of agent functions.
     pub fn functions(&self, names: Option<&[&str]>) -> Vec<Function> {
+        let names: Option<Vec<String>> =
+            names.map(|names| names.iter().map(|n| n.to_ascii_lowercase()).collect());
         self.set
             .iter()
-            .filter_map(|(name, agent)| match names {
+            .filter_map(|(name, agent)| match &names {
                 Some(names) => {
-                    if names.contains(&name.as_str()) {
+                    if names.contains(name) {
                         Some(Function {
                             definition: agent.definition(),
                             supported_resource_tags: agent.supported_resource_tags(),
@@ -299,7 +312,7 @@ where
     /// Extracts resources from the provided list based on the agent's supported tags.
     pub fn select_resources(&self, name: &str, resources: &mut Vec<Resource>) -> Vec<Resource> {
         self.set
-            .get(name)
+            .get(&name.to_ascii_lowercase())
             .map(|agent| {
                 let supported_tags = agent.supported_resource_tags();
                 select_resources(resources, &supported_tags)
@@ -311,7 +324,7 @@ where
     ///
     /// # Arguments
     /// - `agent`: The agent to register, must implement [`Agent`] trait.
-    pub fn add<T>(&mut self, agent: T) -> Result<(), BoxError>
+    pub fn add<T>(&mut self, agent: T, label: Option<String>) -> Result<(), BoxError>
     where
         T: Agent<C> + Send + Sync + 'static,
     {
@@ -321,13 +334,17 @@ where
         }
 
         validate_function_name(&name)?;
-        let agent_dyn = AgentWrapper(Arc::new(agent), PhantomData);
+        let agent_dyn = AgentWrapper {
+            inner: Arc::new(agent),
+            label: label.unwrap_or_else(|| name.clone()),
+            _phantom: PhantomData,
+        };
         self.set.insert(name, Box::new(agent_dyn));
         Ok(())
     }
 
     /// Retrieves an agent by name.
     pub fn get(&self, name: &str) -> Option<&dyn AgentDyn<C>> {
-        self.set.get(name).map(|v| &**v)
+        self.set.get(&name.to_ascii_lowercase()).map(|v| &**v)
     }
 }

anda_core/src/http.rs

@@ -231,7 +231,7 @@ pub async fn cbor_rpc(
     body: Vec<u8>,
 ) -> Result<ByteBufB64, HttpRPCError> {
     let mut headers = headers.unwrap_or_default();
-    let ct: http::HeaderValue = CONTENT_TYPE_CBOR.parse().unwrap();
+    let ct: http::HeaderValue = http::HeaderValue::from_static(CONTENT_TYPE_CBOR);
     headers.insert(header::CONTENT_TYPE, ct.clone());
     headers.insert(header::ACCEPT, ct);
     let res = client

anda_core/src/model/resource.rs

@@ -79,10 +79,7 @@ pub fn update_resources(user: &Principal, resources: Vec<Resource>) -> Vec<Resou
             }
 
             if r._id == 0 {
-                if r.metadata.is_none() {
-                    r.metadata = Some(Map::new());
-                }
-                let meta = r.metadata.as_mut().unwrap();
+                let meta = r.metadata.get_or_insert_with(Map::new);
                 meta.insert("user".to_string(), user.clone().into());
                 meta.insert("created_at".to_string(), utc.clone().into());
             }

anda_core/src/tool.rs

@@ -221,7 +221,7 @@ where
 
     /// Checks if a tool with the given name exists in the set
     pub fn contains(&self, name: &str) -> bool {
-        self.set.contains_key(name)
+        self.set.contains_key(&name.to_ascii_lowercase())
     }
 
     /// Returns the names of all tools in the set
@@ -231,7 +231,9 @@ where
 
     /// Retrieves definition for a specific agent.
     pub fn definition(&self, name: &str) -> Option<FunctionDefinition> {
-        self.set.get(name).map(|tool| tool.definition())
+        self.set
+            .get(&name.to_ascii_lowercase())
+            .map(|tool| tool.definition())
     }
 
     /// Returns definitions for all or specified tools.
@@ -242,11 +244,13 @@ where
     /// # Returns
     /// - Vec<[`FunctionDefinition`]>: Vector of agent definitions.
     pub fn definitions(&self, names: Option<&[&str]>) -> Vec<FunctionDefinition> {
+        let names: Option<Vec<String>> =
+            names.map(|names| names.iter().map(|n| n.to_ascii_lowercase()).collect());
         self.set
             .iter()
-            .filter_map(|(name, tool)| match names {
+            .filter_map(|(name, tool)| match &names {
                 Some(names) => {
-                    if names.contains(&name.as_str()) {
+                    if names.contains(name) {
                         Some(tool.definition())
                     } else {
                         None
@@ -265,11 +269,13 @@ where
     /// # Returns
     /// - Vec<[`Function`]>: Vector of tool functions.
     pub fn functions(&self, names: Option<&[&str]>) -> Vec<Function> {
+        let names: Option<Vec<String>> =
+            names.map(|names| names.iter().map(|n| n.to_ascii_lowercase()).collect());
         self.set
             .iter()
-            .filter_map(|(name, tool)| match names {
+            .filter_map(|(name, tool)| match &names {
                 Some(names) => {
-                    if names.contains(&name.as_str()) {
+                    if names.contains(name) {
                         Some(Function {
                             definition: tool.definition(),
                             supported_resource_tags: tool.supported_resource_tags(),
@@ -289,7 +295,7 @@ where
     /// Extracts resources from the provided list based on the tool's supported tags.
     pub fn select_resources(&self, name: &str, resources: &mut Vec<Resource>) -> Vec<Resource> {
         self.set
-            .get(name)
+            .get(&name.to_ascii_lowercase())
             .map(|tool| {
                 let supported_tags = tool.supported_resource_tags();
                 select_resources(resources, &supported_tags)
@@ -305,7 +311,7 @@ where
     where
         T: Tool<C> + Send + Sync + 'static,
     {
-        let name = tool.name();
+        let name = tool.name().to_ascii_lowercase();
         validate_function_name(&name)?;
         if self.set.contains_key(&name) {
             return Err(format!("tool {} already exists", name).into());
@@ -318,6 +324,6 @@ where
 
     /// Retrieves a tool by name
     pub fn get(&self, name: &str) -> Option<&dyn ToolDyn<C>> {
-        self.set.get(name).map(|v| &**v)
+        self.set.get(&name.to_ascii_lowercase()).map(|v| &**v)
     }
 }