Fix UTF-8 panics in string truncation and improve OpenAI argument parsing

Author: alexylon

src/api/openai.rs

@@ -194,8 +194,7 @@ impl OpenAIClient {
 
                     if let Some(tool_calls) = item.tool_calls {
                         for call in tool_calls {
-                            let input = serde_json::from_str::<serde_json::Value>(&call.arguments)
-                                .unwrap_or_else(|_| json!({"raw_arguments": call.arguments}));
+                            let input = parse_tool_arguments(&call.arguments);
                             content_blocks.push(ContentBlock::ToolUse {
                                 id: call.id,
                                 name: call.name,
@@ -208,8 +207,7 @@ impl OpenAIClient {
                     if let (Some(name), Some(arguments), Some(call_id)) =
                         (item.name, item.arguments, item.call_id)
                     {
-                        let input = serde_json::from_str::<serde_json::Value>(&arguments)
-                            .unwrap_or_else(|_| json!({"raw_arguments": arguments}));
+                        let input = parse_tool_arguments(&arguments);
                         content_blocks.push(ContentBlock::ToolUse {
                             id: call_id,
                             name,
@@ -259,6 +257,44 @@ impl OpenAIClient {
     }
 }
 
+/// Try to parse tool call arguments as JSON, with recovery for common issues.
+fn parse_tool_arguments(args: &str) -> serde_json::Value {
+    // Try normal parsing first
+    if let Ok(v) = serde_json::from_str::<serde_json::Value>(args) {
+        return v;
+    }
+
+    // Try trimming whitespace
+    let trimmed = args.trim();
+    if trimmed != args {
+        if let Ok(v) = serde_json::from_str::<serde_json::Value>(trimmed) {
+            return v;
+        }
+    }
+
+    // Try removing trailing commas before } or ]
+    let fixed = trimmed.replace(",}", "}").replace(",]", "]");
+    if fixed != trimmed {
+        if let Ok(v) = serde_json::from_str::<serde_json::Value>(&fixed) {
+            return v;
+        }
+    }
+
+    // Try adding missing closing brace
+    if trimmed.starts_with('{') && !trimmed.ends_with('}') {
+        let braced = format!("{}}}", trimmed.trim_end_matches(','));
+        if let Ok(v) = serde_json::from_str::<serde_json::Value>(&braced) {
+            return v;
+        }
+    }
+
+    eprintln!(
+        "  \x1b[33m⚠\x1b[0m Failed to parse tool arguments as JSON: {}",
+        &args[..args.len().min(200)]
+    );
+    json!({"raw_arguments": args})
+}
+
 fn build_response_input(request: &CreateMessageRequest) -> Vec<serde_json::Value> {
     let mut input = Vec::new();
 

src/repl/conversation.rs

@@ -296,8 +296,19 @@ Show imperial units only when the user explicitly asks for them."#,
                         if result_text.len() > threshold {
                             let original_len = result_text.len();
                             let actual_keep = keep_chars.min(original_len / 3);
-                            let start = &result_text[..actual_keep];
-                            let end = &result_text[result_text.len() - actual_keep..];
+                            // Snap to char boundaries to avoid panicking on multi-byte chars
+                            let mut start_end = actual_keep;
+                            while start_end < original_len
+                                && !result_text.is_char_boundary(start_end)
+                            {
+                                start_end += 1;
+                            }
+                            let mut end_start = original_len.saturating_sub(actual_keep);
+                            while end_start > 0 && !result_text.is_char_boundary(end_start) {
+                                end_start -= 1;
+                            }
+                            let start = &result_text[..start_end];
+                            let end = &result_text[end_start..];
                             *result_text = format!(
                                 "{}\n...[truncated {} chars]...\n{}",
                                 start, original_len, end
@@ -333,15 +344,21 @@ Show imperial units only when the user explicitly asks for them."#,
                             crate::api::MessageContentBlock::ToolUse { name, input, .. } => {
                                 let input_str = serde_json::to_string(input).unwrap_or_default();
                                 let input_preview = if input_str.len() > 200 {
-                                    format!("{}...", &input_str[..200])
+                                    format!(
+                                        "{}...",
+                                        &input_str[..truncate_at_char_boundary(&input_str, 200)]
+                                    )
                                 } else {
                                     input_str
                                 };
                                 parts.push(format!("[Tool call: {}({})]", name, input_preview));
                             }
                             crate::api::MessageContentBlock::ToolResult { content, .. } => {
                                 let preview = if content.len() > 300 {
-                                    format!("{}...", &content[..300])
+                                    format!(
+                                        "{}...",
+                                        &content[..truncate_at_char_boundary(content, 300)]
+                                    )
                                 } else {
                                     content.clone()
                                 };
@@ -431,6 +448,18 @@ Show imperial units only when the user explicitly asks for them."#,
     }
 }
 
+/// Find the largest byte index <= `max_bytes` that is a char boundary.
+fn truncate_at_char_boundary(s: &str, max_bytes: usize) -> usize {
+    if max_bytes >= s.len() {
+        return s.len();
+    }
+    let mut i = max_bytes;
+    while i > 0 && !s.is_char_boundary(i) {
+        i -= 1;
+    }
+    i
+}
+
 impl Default for ConversationHistory {
     fn default() -> Self {
         Self::new()

src/tools/bashexec.rs

@@ -12,8 +12,11 @@ const MAX_TOOL_OUTPUT_TOKENS: usize = 16_000; // ~56KB, prevents excessive conte
 fn truncate_for_context(content: &str, max_tokens: usize) -> String {
     let estimated_tokens = content.len() / 4;
     if estimated_tokens > max_tokens {
-        let truncate_at = max_tokens * 4;
-        let truncated_content = &content[..truncate_at.min(content.len())];
+        let mut truncate_at = (max_tokens * 4).min(content.len());
+        while truncate_at > 0 && !content.is_char_boundary(truncate_at) {
+            truncate_at -= 1;
+        }
+        let truncated_content = &content[..truncate_at];
         format!(
             "{}...\n\n[TRUNCATED: Output has ~{} tokens, showing first ~{} tokens. Re-run with output redirection if you need the full output.]",
             truncated_content, estimated_tokens, max_tokens
@@ -426,7 +429,7 @@ impl BashExecutor {
         {
             return format!(
                 "Command '{}' contains output redirection ('>' or '>>')\n\
-                 Hint: Use write_file tool to create or modify files. Note: '2>&1' is allowed.",
+                 Hint: Use write_file tool to create or edit_file/morph_edit_file to modify files. Note: '2>&1' is allowed.",
                 command
             );
         }

src/tools/mod.rs

@@ -137,6 +137,19 @@ impl ToolExecutor {
     }
 
     pub async fn execute(&self, tool_name: &str, input: &Value) -> Result<ToolExecutionResult> {
+        // Recover from raw_arguments fallback (malformed JSON from model)
+        let recovered;
+        let input = if let Some(raw) = input.get("raw_arguments").and_then(|v| v.as_str()) {
+            if input.as_object().is_none_or(|o| o.len() == 1) {
+                recovered = serde_json::from_str::<Value>(raw.trim()).unwrap_or(input.clone());
+                &recovered
+            } else {
+                input
+            }
+        } else {
+            input
+        };
+
         // Check if this is an MCP tool first
         if let Some(mcp_manager) = &self.mcp_manager {
             if mcp_manager.is_mcp_tool(tool_name).await {
@@ -704,12 +717,16 @@ impl ToolExecutor {
 
                 let text = utils::html_to_text(&body);
 
-                let max_chars = 64_000;
-                let truncated = if text.len() > max_chars {
+                let max_bytes = 64_000;
+                let truncated = if text.len() > max_bytes {
+                    let mut end = max_bytes;
+                    while end > 0 && !text.is_char_boundary(end) {
+                        end -= 1;
+                    }
                     format!(
                         "{}\n\n[TRUNCATED: showing first ~{} chars of {}]",
-                        &text[..max_chars],
-                        max_chars,
+                        &text[..end],
+                        max_bytes,
                         text.len()
                     )
                 } else {