- Only 18 errors missing being fixed.

src/automation/mod.rs

@@ -194,8 +194,14 @@ impl AutomationService {
 
     async fn execute_action(&self, param: &str) {
         let full_path = Path::new(&self.scripts_dir).join(param);
-        match tokio::fs::read_to_string(&full_path).await {
+        let script_content = match tokio::fs::read_to_string(&full_path).await {
-            Ok(script_content) => {
+            Ok(content) => content,
+            Err(e) => {
+                error!("Failed to read script {}: {}", full_path.display(), e);
+                return;
+            }
+        };
+
         info!("Executing action with param: {}", param);
         let user_session = crate::shared::models::UserSession {
             id: Uuid::new_v4(),
@@ -204,21 +210,26 @@ impl AutomationService {
             title: "Automation".to_string(),
             answer_mode: "direct".to_string(),
             current_tool: None,
-                    context_data: None,
+            context_data: serde_json::Value::Null,
             created_at: Utc::now(),
             updated_at: Utc::now(),
         };
+
         let script_service = ScriptService::new(&self.state, user_session);
-                match script_service.compile(&script_content) {
+        let ast = match script_service.compile(&script_content) {
-                    Ok(ast) => match script_service.run(&ast) {
+            Ok(ast) => ast,
-                        Ok(result) => info!("Script executed successfully: {:?}", result),
+            Err(e) => {
-                        Err(e) => error!("Error executing script: {}", e),
+                error!("Error compiling script: {}", e);
-                    },
+                return;
-                    Err(e) => error!("Error compiling script: {}", e),
             }
+        };
+
+        match script_service.run(&ast) {
+            Ok(_result) => {
+                info!("Script executed successfully");
             }
             Err(e) => {
-                error!("Failed to execute action {}: {}", full_path.display(), e);
+                error!("Error executing script: {}", e);
             }
         }
     }

src/basic/keywords/set.rs

@@ -8,7 +8,7 @@ use std::error::Error;
 use crate::shared::models::UserSession;
 use crate::shared::state::AppState;
 
-pub fn set_keyword(state: &AppState, user: UserSession, engine: &mut Engine) {
+pub fn set_keyword(state: &AppState, _user: UserSession, engine: &mut Engine) {
     let state_clone = state.clone();
 
     engine
@@ -22,8 +22,8 @@ pub fn set_keyword(state: &AppState, user: UserSession, engine: &mut Engine) {
                 let filter_str = filter.to_string();
                 let updates_str = updates.to_string();
 
-                let conn = state_clone.conn.lock().unwrap();
+                let mut conn = state_clone.conn.lock().unwrap();
-                let result = execute_set(&*conn, &table_str, &filter_str, &updates_str)
+                let result = execute_set(&mut *conn, &table_str, &filter_str, &updates_str)
                     .map_err(|e| format!("DB error: {}", e))?;
 
                 if let Some(rows_affected) = result.get("rows_affected") {

src/basic/keywords/set_schedule.rs

@@ -1,14 +1,14 @@
+use diesel::prelude::*;
 use log::info;
 use rhai::Dynamic;
 use rhai::Engine;
 use serde_json::{json, Value};
-use diesel::prelude::*;
 
 use crate::shared::models::TriggerKind;
-use crate::shared::state::AppState;
 use crate::shared::models::UserSession;
+use crate::shared::state::AppState;
 
-pub fn set_schedule_keyword(state: &AppState, user: UserSession, engine: &mut Engine) {
+pub fn set_schedule_keyword(state: &AppState, _user: UserSession, engine: &mut Engine) {
     let state_clone = state.clone();
 
     engine
@@ -17,8 +17,8 @@ pub fn set_schedule_keyword(state: &AppState, user: UserSession, engine: &mut En
                 let cron = context.eval_expression_tree(&inputs[0])?.to_string();
                 let script_name = format!("cron_{}.rhai", cron.replace(' ', "_"));
 
-                let conn = state_clone.conn.lock().unwrap();
+                let mut conn = state_clone.conn.lock().unwrap();
-                let result = execute_set_schedule(&*conn, &cron, &script_name)
+                let result = execute_set_schedule(&mut *conn, &cron, &script_name)
                     .map_err(|e| format!("DB error: {}", e))?;
 
                 if let Some(rows_affected) = result.get("rows_affected") {
@@ -32,7 +32,7 @@ pub fn set_schedule_keyword(state: &AppState, user: UserSession, engine: &mut En
 }
 
 pub fn execute_set_schedule(
-    conn: &diesel::PgConnection,
+    conn: &mut diesel::PgConnection,
     cron: &str,
     script_name: &str,
 ) -> Result<Value, Box<dyn std::error::Error>> {
@@ -51,7 +51,7 @@ pub fn execute_set_schedule(
 
     let result = diesel::insert_into(system_automations::table)
         .values(&new_automation)
-        .execute(conn)?;
+        .execute(&mut *conn)?;
 
     Ok(json!({
         "command": "set_schedule",

src/bot/mod.rs

@@ -187,7 +187,7 @@ impl BotOrchestrator {
         message: &UserMessage,
         session: &UserSession,
     ) -> Result<String, Box<dyn std::error::Error + Send + Sync>> {
-        let session_manager = self.session_manager.lock().await;
+        let mut session_manager = self.session_manager.lock().await;
         let history = session_manager.get_conversation_history(session.id, session.user_id)?;
 
         let mut prompt = String::new();
@@ -220,11 +220,9 @@ impl BotOrchestrator {
         };
 
         if session.answer_mode == "tool" && session.current_tool.is_some() {
-            self.tool_manager.provide_user_response(
+            self.tool_manager
-                &message.user_id,
+                .provide_user_response(&message.user_id, &message.bot_id, message.content.clone())
-                &message.bot_id,
+                .await?;
-                message.content.clone(),
-            )?;
             return Ok(());
         }
 
@@ -310,7 +308,7 @@ impl BotOrchestrator {
         &self,
         user_id: Uuid,
     ) -> Result<Vec<UserSession>, Box<dyn std::error::Error + Send + Sync>> {
-        let session_manager = self.session_manager.lock().await;
+        let mut session_manager = self.session_manager.lock().await;
         session_manager.get_user_sessions(user_id)
     }
 
@@ -319,7 +317,7 @@ impl BotOrchestrator {
         session_id: Uuid,
         user_id: Uuid,
     ) -> Result<Vec<(String, String)>, Box<dyn std::error::Error + Send + Sync>> {
-        let session_manager = self.session_manager.lock().await;
+        let mut session_manager = self.session_manager.lock().await;
         session_manager.get_conversation_history(session_id, user_id)
     }
 

src/session/mod.rs

@@ -18,15 +18,15 @@ impl SessionManager {
 
     pub fn get_user_session(
         &mut self,
-        user_id: Uuid,
+        user_id_param: Uuid,
-        bot_id: Uuid,
+        bot_id_param: Uuid,
     ) -> Result<Option<UserSession>, Box<dyn std::error::Error + Send + Sync>> {
         if let Some(redis_client) = &self.redis {
             let mut conn = tokio::task::block_in_place(|| {
                 tokio::runtime::Handle::current()
                     .block_on(redis_client.get_multiplexed_async_connection())
             })?;
-            let cache_key = format!("session:{}:{}", user_id, bot_id);
+            let cache_key = format!("session:{}:{}", user_id_param, bot_id_param);
             let session_json: Option<String> = tokio::task::block_in_place(|| {
                 tokio::runtime::Handle::current().block_on(conn.get(&cache_key))
             })?;
@@ -40,8 +40,8 @@ impl SessionManager {
         use crate::shared::models::user_sessions::dsl::*;
 
         let session = user_sessions
-            .filter(user_id.eq(user_id))
+            .filter(user_id.eq(user_id_param))
-            .filter(bot_id.eq(bot_id))
+            .filter(bot_id.eq(bot_id_param))
             .order_by(updated_at.desc())
             .first::<UserSession>(&mut self.conn)
             .optional()?;
@@ -52,7 +52,7 @@ impl SessionManager {
                     tokio::runtime::Handle::current()
                         .block_on(redis_client.get_multiplexed_async_connection())
                 })?;
-                let cache_key = format!("session:{}:{}", user_id, bot_id);
+                let cache_key = format!("session:{}:{}", user_id_param, bot_id_param);
                 let session_json = serde_json::to_string(session)?;
                 let _: () = tokio::task::block_in_place(|| {
                     tokio::runtime::Handle::current().block_on(conn.set_ex(
@@ -86,6 +86,7 @@ impl SessionManager {
 
         let session = insert_into(user_sessions::table)
             .values(&new_session)
+            .returning(UserSession::as_returning())
             .get_result::<UserSession>(&mut self.conn)?;
 
         if let Some(redis_client) = &self.redis {
@@ -110,7 +111,7 @@ impl SessionManager {
     pub fn save_message(
         &mut self,
         session_id: Uuid,
-        user_id: Uuid,
+        user_id_param: Uuid,
         role: &str,
         content: &str,
         message_type: &str,
@@ -125,7 +126,7 @@ impl SessionManager {
 
         let new_message = (
             message_history::session_id.eq(session_id),
-            message_history::user_id.eq(user_id),
+            message_history::user_id.eq(user_id_param),
             message_history::role.eq(role),
             message_history::content_encrypted.eq(content),
             message_history::message_type.eq(message_type),
@@ -165,8 +166,8 @@ impl SessionManager {
 
     pub fn get_conversation_history(
         &mut self,
-        session_id: Uuid,
+        _session_id: Uuid,
-        user_id: Uuid,
+        _user_id: Uuid,
     ) -> Result<Vec<(String, String)>, Box<dyn std::error::Error + Send + Sync>> {
         use crate::shared::models::message_history::dsl::*;
 
@@ -182,12 +183,12 @@ impl SessionManager {
 
     pub fn get_user_sessions(
         &mut self,
-        user_id: Uuid,
+        user_id_param: Uuid,
     ) -> Result<Vec<UserSession>, Box<dyn std::error::Error + Send + Sync>> {
         use crate::shared::models::user_sessions::dsl::*;
 
         let sessions = user_sessions
-            .filter(user_id.eq(user_id))
+            .filter(user_id.eq(user_id_param))
             .order_by(updated_at.desc())
             .load::<UserSession>(&mut self.conn)?;
         Ok(sessions)
@@ -195,14 +196,14 @@ impl SessionManager {
 
     pub fn update_answer_mode(
         &mut self,
-        user_id: &str,
+        user_id_param: &str,
-        bot_id: &str,
+        bot_id_param: &str,
         mode: &str,
     ) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
         use crate::shared::models::user_sessions::dsl::*;
 
-        let user_uuid = Uuid::parse_str(user_id)?;
+        let user_uuid = Uuid::parse_str(user_id_param)?;
-        let bot_uuid = Uuid::parse_str(bot_id)?;
+        let bot_uuid = Uuid::parse_str(bot_id_param)?;
 
         diesel::update(
             user_sessions
@@ -228,14 +229,14 @@ impl SessionManager {
 
     pub fn update_current_tool(
         &mut self,
-        user_id: &str,
+        user_id_param: &str,
-        bot_id: &str,
+        bot_id_param: &str,
         tool_name: Option<&str>,
     ) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
         use crate::shared::models::user_sessions::dsl::*;
 
-        let user_uuid = Uuid::parse_str(user_id)?;
+        let user_uuid = Uuid::parse_str(user_id_param)?;
-        let bot_uuid = Uuid::parse_str(bot_id)?;
+        let bot_uuid = Uuid::parse_str(bot_id_param)?;
 
         diesel::update(
             user_sessions
@@ -321,21 +322,24 @@ impl SessionManager {
 
     pub fn set_current_tool(
         &mut self,
-        user_id: &str,
+        user_id_param: &str,
-        bot_id: &str,
+        bot_id_param: &str,
         tool_name: Option<String>,
     ) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
         use crate::shared::models::user_sessions::dsl::*;
 
-        let user_uuid = Uuid::parse_str(user_id)?;
+        let user_uuid = Uuid::parse_str(user_id_param)?;
-        let bot_uuid = Uuid::parse_str(bot_id)?;
+        let bot_uuid = Uuid::parse_str(bot_id_param)?;
 
         diesel::update(
             user_sessions
                 .filter(user_id.eq(user_uuid))
                 .filter(bot_id.eq(bot_uuid)),
         )
-        .set((current_tool.eq(tool_name), updated_at.eq(diesel::dsl::now)))
+        .set((
+            current_tool.eq(tool_name.as_deref()),
+            updated_at.eq(diesel::dsl::now),
+        ))
         .execute(&mut self.conn)?;
 
         if let Some(redis_client) = &self.redis {

src/shared/state.rs

@@ -28,6 +28,7 @@ impl Clone for AppState {
             s3_client: self.s3_client.clone(),
             config: self.config.clone(),
             conn: Arc::clone(&self.conn),
+            custom_conn: Arc::clone(&self.custom_conn),
             redis_client: self.redis_client.clone(),
             orchestrator: Arc::clone(&self.orchestrator),
             web_adapter: Arc::clone(&self.web_adapter),

src/whatsapp/mod.rs

@@ -141,7 +141,8 @@ impl WhatsAppAdapter {
     pub async fn process_incoming_message(
         &self,
         message: WhatsAppMessage,
-    ) -> Result<Vec<crate::shared::UserMessage>, Box<dyn std::error::Error + Send + Sync>> {
+    ) -> Result<Vec<crate::shared::models::UserMessage>, Box<dyn std::error::Error + Send + Sync>>
+    {
         let mut user_messages = Vec::new();
 
         for entry in message.entry {