Upgrade rust tools on node startup.

guillevalin · guillevalin · commit a40c8be3c92e · 2025-09-22T16:17:09.000-04:00
diff --git a/shinkai-bin/shinkai-node/src/llm_provider/execution/prompts/prompt_test.rs b/shinkai-bin/shinkai-node/src/llm_provider/execution/prompts/prompt_test.rs
@@ -52,6 +52,7 @@ mod tests {
             ToolOutputArg::empty(),
             None,
             "local:::__official_shinkai:::concat_strings".to_string(),
+            "1.0.0".to_string(),
         );
         let shinkai_tool = ShinkaiTool::Rust(tool, true);
 
@@ -216,6 +217,7 @@ mod tests {
             ToolOutputArg::empty(),
             None,
             "local:::__official_shinkai:::concat_strings".to_string(),
+            "1.0.0".to_string(),
         );
         let shinkai_tool = ShinkaiTool::Rust(tool, true);
 
diff --git a/shinkai-bin/shinkai-node/src/managers/tool_router.rs b/shinkai-bin/shinkai-node/src/managers/tool_router.rs
@@ -596,6 +596,7 @@ impl ToolRouter {
         println!("Adding {} Rust tools", rust_tools.len());
         let mut added_count = 0;
         let mut skipped_count = 0;
+        let mut upgraded_count = 0;
 
         for tool in rust_tools {
             let rust_tool = RustTool::new(
@@ -605,26 +606,66 @@ impl ToolRouter {
                 tool.output_arg,
                 None,
                 tool.tool_router_key,
+                tool.version,
             );
 
-            let _ = match self.sqlite_manager.get_tool_by_key(&rust_tool.tool_router_key) {
+            let router_key = rust_tool.tool_router_key.clone();
+            let new_version = IndexableVersion::from_string(&rust_tool.version).map_err(|e| {
+                ToolError::ParseError(format!("Invalid Rust tool version '{}': {}", rust_tool.version, e))
+            })?;
+
+            match self.sqlite_manager.get_tool_header_by_key(&router_key) {
                 Err(SqliteManagerError::ToolNotFound(_)) => {
                     added_count += 1;
                     self.sqlite_manager
                         .add_tool(ShinkaiTool::Rust(rust_tool, true))
                         .await
-                        .map_err(|e| ToolError::DatabaseError(e.to_string()))
+                        .map_err(|e| ToolError::DatabaseError(e.to_string()))?;
                 }
-                Err(e) => Err(ToolError::DatabaseError(e.to_string())),
-                Ok(_db_tool) => {
-                    skipped_count += 1;
-                    continue;
+                Err(e) => return Err(ToolError::DatabaseError(e.to_string())),
+                Ok(header) => {
+                    let current_version = IndexableVersion::from_string(&header.version).map_err(|e| {
+                        ToolError::ParseError(format!(
+                            "Invalid installed Rust tool version '{}': {}",
+                            header.version, e
+                        ))
+                    })?;
+
+                    if new_version > current_version {
+                        match self.sqlite_manager.get_tool_by_key(&router_key) {
+                            Ok(ShinkaiTool::Rust(existing_rust_tool, is_enabled)) => {
+                                let mut upgraded_tool = rust_tool.clone();
+                                if upgraded_tool.mcp_enabled.is_none() {
+                                    upgraded_tool.mcp_enabled = existing_rust_tool.mcp_enabled;
+                                }
+
+                                upgraded_count += 1;
+                                self.sqlite_manager
+                                    .upgrade_tool(ShinkaiTool::Rust(upgraded_tool, is_enabled))
+                                    .await
+                                    .map_err(|e| ToolError::DatabaseError(e.to_string()))?;
+                            }
+                            Ok(other_variant) => {
+                                skipped_count += 1;
+                                eprintln!(
+                                    "Expected Rust tool for key '{}' but found {:?}, skipping",
+                                    router_key,
+                                    other_variant.tool_type()
+                                );
+                            }
+                            Err(err) => {
+                                return Err(ToolError::DatabaseError(err.to_string()));
+                            }
+                        }
+                    } else {
+                        skipped_count += 1;
+                    }
                 }
-            }?;
+            }
         }
         println!(
-            "Rust tools installation complete - Added: {}, Skipped: {}",
-            added_count, skipped_count
+            "Rust tools installation complete - Added: {}, Upgraded: {}, Skipped: {}",
+            added_count, upgraded_count, skipped_count
         );
         Ok(())
     }
diff --git a/shinkai-bin/shinkai-node/src/tools/tool_implementation/native_tools/sql_processor.rs b/shinkai-bin/shinkai-node/src/tools/tool_implementation/native_tools/sql_processor.rs
@@ -58,13 +58,16 @@ INSERT INTO table_name (field_1, field_3, field_4)
 
 -- Example read:
 SELECT * FROM table_name WHERE field_2 > datetime('now', '-1 day');
-SELECT field_1, field_3 FROM table_name WHERE field_3 > 100 ORDER BY field_2 DESC LIMIT 10;"#
+SELECT field_1, field_3 FROM table_name WHERE field_3 > 100 ORDER BY field_2 DESC LIMIT 10;
+
+-- Changelog:
+- 1.0.1: Fixed parameters to be compliant with JSON schema."#
                     .to_string(),
                 tool_router_key: "local:::__official_shinkai:::shinkai_sqlite_query_executor".to_string(),
                 tool_type: "Rust".to_string(),
                 formatted_tool_summary_for_ui: "Execute SQLite queries".to_string(),
                 author: "@@official.shinkai".to_string(),
-                version: "1.0".to_string(),
+                version: "1.0.1".to_string(),
                 enabled: true,
                 mcp_enabled: Some(false),
                 input_args: {
@@ -311,6 +314,7 @@ mod tests {
             mcp_enabled: sql_processor_tool.tool.mcp_enabled.clone(),
             input_args: sql_processor_tool.tool.input_args.clone(),
             output_arg: sql_processor_tool.tool.output_arg.clone(),
+            version: sql_processor_tool.tool.version.clone(),
             tool_embedding: sql_processor_tool._tool_embedding.clone(),
             tool_router_key: sql_processor_tool.tool.tool_router_key.clone(),
         };
diff --git a/shinkai-libs/shinkai-sqlite/src/shinkai_tool_manager.rs b/shinkai-libs/shinkai-sqlite/src/shinkai_tool_manager.rs
@@ -295,6 +295,9 @@ impl SqliteManager {
                 new_python.config = merged_config;
                 (old_config, ShinkaiTool::Python(new_python, is_enabled))
             }
+            (ShinkaiTool::Rust(_old_rust, _), ShinkaiTool::Rust(new_rust, is_enabled)) => {
+                (Vec::new(), ShinkaiTool::Rust(new_rust, is_enabled))
+            }
             _ => return Err(SqliteManagerError::ToolTypeMismatch),
         };
 
diff --git a/shinkai-libs/shinkai-tools-primitives/src/tools/rust_tools.rs b/shinkai-libs/shinkai-tools-primitives/src/tools/rust_tools.rs
@@ -27,12 +27,18 @@ impl fmt::Display for RustToolError {
 
 impl std::error::Error for RustToolError {}
 
+fn default_rust_tool_version() -> String {
+    "1.0.0".to_string()
+}
+
 #[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct RustTool {
     pub name: String,
     pub description: String,
     pub input_args: Parameters,
     pub output_arg: ToolOutputArg,
+    #[serde(default = "default_rust_tool_version")]
+    pub version: String,
     pub tool_embedding: Option<Vec<f32>>,
     pub tool_router_key: String,
     pub mcp_enabled: Option<bool>,
@@ -46,12 +52,14 @@ impl RustTool {
         output_arg: ToolOutputArg,
         tool_embedding: Option<Vec<f32>>,
         tool_router_key: String,
+        version: String,
     ) -> Self {
         Self {
             name: utils::clean_string(&name),
             description,
             input_args,
             output_arg,
+            version,
             tool_embedding,
             tool_router_key,
             mcp_enabled: Some(false),
@@ -79,6 +87,7 @@ impl RustTool {
             description: header.description.clone(),
             input_args: header.input_args.clone(),
             output_arg: header.output_arg.clone(),
+            version: header.version.clone(),
             tool_embedding: None, // Assuming no embedding is provided in the header
             tool_router_key: header.tool_router_key.clone(),
             mcp_enabled: header.mcp_enabled,
@@ -106,7 +115,7 @@ impl RustTool {
 
         ToolPlaygroundMetadata {
             name: self.name.clone(),
-            version: "1.0.0".to_string(),
+            version: self.version.clone(),
             homepage: None,
             description: self.description.clone(),
             author: self.author(),
diff --git a/shinkai-libs/shinkai-tools-primitives/src/tools/shinkai_tool.rs b/shinkai-libs/shinkai-tools-primitives/src/tools/shinkai_tool.rs
@@ -402,7 +402,7 @@ impl ShinkaiTool {
     /// Returns the version of the tool
     pub fn version(&self) -> String {
         match self {
-            ShinkaiTool::Rust(_r, _) => "1.0.0".to_string(),
+            ShinkaiTool::Rust(r, _) => r.version.clone(),
             ShinkaiTool::Network(n, _) => n.version.clone(),
             ShinkaiTool::Deno(d, _) => d.version.clone(),
             ShinkaiTool::Python(p, _) => p.version.clone(),

Original file line number	Diff line number	Diff line change
`@@ -295,6 +295,9 @@ impl SqliteManager {`
`295`	`295`	`new_python.config = merged_config;`
`296`	`296`	`(old_config, ShinkaiTool::Python(new_python, is_enabled))`
`297`	`297`	`}`
	`298`	`+ (ShinkaiTool::Rust(_old_rust, _), ShinkaiTool::Rust(new_rust, is_enabled)) => {`
	`299`	`+ (Vec::new(), ShinkaiTool::Rust(new_rust, is_enabled))`
	`300`	`+ }`
`298`	`301`	`_ => return Err(SqliteManagerError::ToolTypeMismatch),`
`299`	`302`	`};`
`300`	`303`