Merge pull request tinyhumansai#38 from graycyrus/develop

fixes: conversation fixes

Author: graycyrus

CLAUDE.md

@@ -471,6 +471,12 @@ Key updates from recent commits (cd9ebcd to current):
 
 ## Key Patterns
 
+- **MANDATORY: Pre-completion checks**: Before considering ANY task complete, ALWAYS run these checks and fix all errors:
+  1. `npx prettier --check .` (formatting)
+  2. `npx eslint .` (lint)
+  3. `npx tsc --noEmit` (TypeScript)
+  4. `cargo fmt --manifest-path src-tauri/Cargo.toml` (Rust formatting, if Rust files were changed)
+  5. `cargo check --manifest-path src-tauri/Cargo.toml` (Rust compilation, if Rust files were changed)
 - **Code Quality**: ESLint and Prettier enforce code standards with Husky hooks. Use type-only imports (`import type`) and consolidate imports from same modules.
 - **No dynamic imports**: All imports must be static `import` statements at the top of the file. Do not use `await import()` or `import().then()` inside functions or code blocks. Use try/catch around Tauri API calls for non-Tauri environments instead.
 - **No localStorage**: Avoid `localStorage` and `sessionStorage`; use Redux (and persist) for app state. Remove any direct usage when working on affected code.

src-tauri/src/ai/encryption.rs

@@ -4,12 +4,12 @@
 //! encrypted at rest using AES-256-GCM. Keys are derived from a user
 //! password via Argon2id.
 
+use aes_gcm::aead::rand_core::RngCore;
 use aes_gcm::{
     aead::{Aead, KeyInit, OsRng},
     Aes256Gcm, Nonce,
 };
 use argon2::{self, Algorithm, Argon2, Params, Version};
-use aes_gcm::aead::rand_core::RngCore;
 use serde::{Deserialize, Serialize};
 use std::path::PathBuf;
 

src-tauri/src/bin/openhuman-cli.rs

@@ -80,14 +80,10 @@ enum Command {
     },
 
     /// Encrypt a secret
-    Encrypt {
-        plaintext: String,
-    },
+    Encrypt { plaintext: String },
 
     /// Decrypt a secret
-    Decrypt {
-        ciphertext: String,
-    },
+    Decrypt { ciphertext: String },
 
     /// Toggle browser allow-all runtime flag
     BrowserAllowAll {
@@ -324,7 +320,9 @@ fn load_config() -> Result<openhuman::openhuman::config::Config, String> {
         .map_err(|e| format!("failed to load config: {e}"))
 }
 
-fn status_value(status: openhuman::openhuman::service::ServiceStatus) -> Result<serde_json::Value, String> {
+fn status_value(
+    status: openhuman::openhuman::service::ServiceStatus,
+) -> Result<serde_json::Value, String> {
     serde_json::to_value(status).map_err(|e| format!("failed to serialize service status: {e}"))
 }
 

src-tauri/src/commands/auth.rs

@@ -8,7 +8,6 @@ use std::sync::Arc;
 pub static SESSION_SERVICE: Lazy<Arc<SessionService>> =
     Lazy::new(|| Arc::new(SessionService::new()));
 
-
 /// Get the current authentication state
 #[tauri::command]
 pub fn get_auth_state() -> AuthState {

src-tauri/src/commands/chat.rs

@@ -341,9 +341,7 @@ fn is_read_tool(name: &str) -> bool {
 /// Tool names are namespaced as `{skill_id}__{tool_name}`.
 /// Read-only tools are excluded — their data comes from the memory layer (Step 2 context recall).
 #[cfg(not(any(target_os = "android", target_os = "ios")))]
-fn discover_tools(
-    engine: &crate::runtime::qjs_engine::RuntimeEngine,
-) -> Vec<serde_json::Value> {
+fn discover_tools(engine: &crate::runtime::qjs_engine::RuntimeEngine) -> Vec<serde_json::Value> {
     engine
         .all_tools()
         .into_iter()
@@ -436,15 +434,9 @@ pub async fn chat_send(
         chat_state_arc.remove(&thread_id_clone);
 
         if let Err(e) = result {
-            let _ = app_clone.emit(
-                "chat:error",
-                ChatErrorEvent {
-                    thread_id: thread_id_clone,
-                    message: e,
-                    error_type: "inference".to_string(),
-                    round: None,
-                },
-            );
+            // chat_send_inner already emits chat:error for known error paths.
+            // Only log here to avoid duplicate error events.
+            log::error!("[chat] chat_send_inner failed: {e}");
         }
     });
 
@@ -501,15 +493,9 @@ pub async fn chat_send(
         chat_state_arc.remove(&thread_id_clone);
 
         if let Err(e) = result {
-            let _ = app_clone.emit(
-                "chat:error",
-                ChatErrorEvent {
-                    thread_id: thread_id_clone,
-                    message: e,
-                    error_type: "inference".to_string(),
-                    round: None,
-                },
-            );
+            // chat_send_mobile already emits chat:error for known error paths.
+            // Only log here to avoid duplicate error events.
+            log::error!("[chat] chat_send_mobile failed: {e}");
         }
     });
 
@@ -546,7 +532,19 @@ async fn chat_send_inner(
     let client = reqwest::Client::builder()
         .use_rustls_tls()
         .build()
-        .map_err(|e| format!("Failed to build HTTP client: {}", e))?;
+        .map_err(|e| {
+            let msg = format!("Failed to build HTTP client: {}", e);
+            let _ = app.emit(
+                "chat:error",
+                ChatErrorEvent {
+                    thread_id: thread_id.to_string(),
+                    message: msg.clone(),
+                    error_type: "network".to_string(),
+                    round: None,
+                },
+            );
+            msg
+        })?;
 
     // ── Step 1: Load AI context ─────────────────────────────────────────
     let openclaw_context = load_openclaw_context(app);
@@ -583,7 +581,11 @@ async fn chat_send_inner(
         .map(|(skill_id, _)| skill_id)
         .collect();
 
-    log::info!("[chat] Recalling skill contexts for {} skill(s): {:?}", skill_ids.len(), skill_ids);
+    log::info!(
+        "[chat] Recalling skill contexts for {} skill(s): {:?}",
+        skill_ids.len(),
+        skill_ids
+    );
 
     let mut skill_contexts: Vec<String> = Vec::new();
     for sid in &skill_ids {
@@ -932,21 +934,39 @@ async fn chat_send_inner(
         }
 
         // Parse the completion response
-        let completion: ChatCompletionResponse = response
-            .json()
-            .await
-            .map_err(|e| format!("Failed to parse inference response: {}", e))?;
+        let completion: ChatCompletionResponse = response.json().await.map_err(|e| {
+            let msg = format!("Failed to parse inference response: {}", e);
+            let _ = app.emit(
+                "chat:error",
+                ChatErrorEvent {
+                    thread_id: thread_id.to_string(),
+                    message: msg.clone(),
+                    error_type: "inference".to_string(),
+                    round: Some(round),
+                },
+            );
+            msg
+        })?;
 
         // Accumulate token usage
         if let Some(ref usage) = completion.usage {
             total_input_tokens += usage.prompt_tokens;
             total_output_tokens += usage.completion_tokens;
         }
 
-        let choice = completion
-            .choices
-            .first()
-            .ok_or_else(|| "No choices in inference response".to_string())?;
+        let choice = completion.choices.first().ok_or_else(|| {
+            let msg = "No choices in inference response".to_string();
+            let _ = app.emit(
+                "chat:error",
+                ChatErrorEvent {
+                    thread_id: thread_id.to_string(),
+                    message: msg.clone(),
+                    error_type: "inference".to_string(),
+                    round: Some(round),
+                },
+            );
+            msg
+        })?;
 
         log::info!(
             "[chat] Round {} — finish_reason={:?}, tool_calls={}",
@@ -989,9 +1009,8 @@ async fn chat_send_inner(
 
                 let (skill_id, tool_name) = parse_tool_name(&tc.function.name);
 
-                let args_value: serde_json::Value =
-                    serde_json::from_str(&tc.function.arguments)
-                        .unwrap_or_else(|_| serde_json::Value::Object(serde_json::Map::new()));
+                let args_value: serde_json::Value = serde_json::from_str(&tc.function.arguments)
+                    .unwrap_or_else(|_| serde_json::Value::Object(serde_json::Map::new()));
 
                 // Emit tool_call event before executing
                 let _ = app.emit(
@@ -1056,9 +1075,7 @@ async fn chat_send_inner(
                     .content
                     .iter()
                     .filter_map(|c| match c {
-                        crate::runtime::types::ToolContent::Text { text } => {
-                            Some(text.as_str())
-                        }
+                        crate::runtime::types::ToolContent::Text { text } => Some(text.as_str()),
                         crate::runtime::types::ToolContent::Json { .. } => None,
                     })
                     .collect::<Vec<&str>>()
@@ -1067,9 +1084,7 @@ async fn chat_send_inner(
                 // Check for JSON error pattern (matching TS behaviour)
                 let (final_tool_str, final_success) = if !tool_result.is_error {
                     if let Ok(parsed) = serde_json::from_str::<serde_json::Value>(&tool_content) {
-                        if let Some(error_str) =
-                            parsed.get("error").and_then(|e| e.as_str())
-                        {
+                        if let Some(error_str) = parsed.get("error").and_then(|e| e.as_str()) {
                             (format!("Error: {}", error_str), false)
                         } else {
                             (tool_content.clone(), true)
@@ -1162,7 +1177,19 @@ async fn chat_send_mobile(
     let client = reqwest::Client::builder()
         .use_rustls_tls()
         .build()
-        .map_err(|e| format!("Failed to build HTTP client: {}", e))?;
+        .map_err(|e| {
+            let msg = format!("Failed to build HTTP client: {}", e);
+            let _ = app.emit(
+                "chat:error",
+                ChatErrorEvent {
+                    thread_id: thread_id.to_string(),
+                    message: msg.clone(),
+                    error_type: "network".to_string(),
+                    round: None,
+                },
+            );
+            msg
+        })?;
 
     // ── Step 1: Load AI context ─────────────────────────────────────────
     let openclaw_context = load_openclaw_context(app);
@@ -1307,20 +1334,38 @@ async fn chat_send_mobile(
         return Err(msg);
     }
 
-    let completion: ChatCompletionResponse = response
-        .json()
-        .await
-        .map_err(|e| format!("Failed to parse inference response: {}", e))?;
+    let completion: ChatCompletionResponse = response.json().await.map_err(|e| {
+        let msg = format!("Failed to parse inference response: {}", e);
+        let _ = app.emit(
+            "chat:error",
+            ChatErrorEvent {
+                thread_id: thread_id.to_string(),
+                message: msg.clone(),
+                error_type: "inference".to_string(),
+                round: None,
+            },
+        );
+        msg
+    })?;
 
     let (total_input_tokens, total_output_tokens) = completion
         .usage
         .map(|u| (u.prompt_tokens, u.completion_tokens))
         .unwrap_or((0, 0));
 
-    let choice = completion
-        .choices
-        .first()
-        .ok_or_else(|| "No choices in inference response".to_string())?;
+    let choice = completion.choices.first().ok_or_else(|| {
+        let msg = "No choices in inference response".to_string();
+        let _ = app.emit(
+            "chat:error",
+            ChatErrorEvent {
+                thread_id: thread_id.to_string(),
+                message: msg.clone(),
+                error_type: "inference".to_string(),
+                round: None,
+            },
+        );
+        msg
+    })?;
 
     let full_response = choice.message.content.clone().unwrap_or_default();
 

src-tauri/src/commands/memory.rs

@@ -86,7 +86,10 @@ pub async fn init_memory_client(
     jwt_token: String,
     state: tauri::State<'_, MemoryState>,
 ) -> Result<(), String> {
-    log::info!("[memory] init_memory_client: entry (token_present={})", !jwt_token.trim().is_empty());
+    log::info!(
+        "[memory] init_memory_client: entry (token_present={})",
+        !jwt_token.trim().is_empty()
+    );
     let client = MemoryClient::from_token(jwt_token).map(Arc::new);
     if client.is_none() {
         log::warn!("[memory] init_memory_client: exit — empty token, memory layer disabled");
@@ -149,7 +152,10 @@ pub async fn memory_query(
                 .query_skill_context(&skill_id, &integration_id, &query, max_chunks.unwrap_or(10))
                 .await;
             match &result {
-                Ok(ctx) => log::info!("[memory] memory_query: exit — ok (context_len={})", ctx.len()),
+                Ok(ctx) => log::info!(
+                    "[memory] memory_query: exit — ok (context_len={})",
+                    ctx.len()
+                ),
                 Err(e) => log::warn!("[memory] memory_query: exit — error: {e}"),
             }
             result
@@ -218,9 +224,10 @@ pub async fn memory_query_namespace(
 ) -> Result<String, String> {
     let client = state.0.lock().map_err(|e| e.to_string())?.clone();
     match client {
-        Some(c) => c
-            .query_namespace_context(&namespace, &query, max_chunks.unwrap_or(10))
-            .await,
+        Some(c) => {
+            c.query_namespace_context(&namespace, &query, max_chunks.unwrap_or(10))
+                .await
+        }
         None => Err("Memory layer not configured — JWT token not yet set".into()),
     }
 }
@@ -233,9 +240,10 @@ pub async fn memory_recall_namespace(
 ) -> Result<Option<String>, String> {
     let client = state.0.lock().map_err(|e| e.to_string())?.clone();
     match client {
-        Some(c) => c
-            .recall_namespace_context(&namespace, max_chunks.unwrap_or(10))
-            .await,
+        Some(c) => {
+            c.recall_namespace_context(&namespace, max_chunks.unwrap_or(10))
+                .await
+        }
         None => Err("Memory layer not configured — JWT token not yet set".into()),
     }
 }

src-tauri/src/commands/mod.rs

@@ -2,9 +2,9 @@ pub mod auth;
 pub mod chat;
 pub mod memory;
 pub mod model;
+pub mod openhuman;
 pub mod runtime;
 pub mod socket;
-pub mod openhuman;
 pub mod unified_skills;
 
 #[cfg(desktop)]
@@ -15,9 +15,9 @@ pub use auth::*;
 pub use chat::{chat_cancel, chat_send};
 pub use memory::*;
 pub use model::*;
+pub use openhuman::*;
 pub use runtime::*;
 pub use socket::*;
-pub use openhuman::*;
 
 #[cfg(desktop)]
 pub use window::*;