fix: handle invalid image URLs in conversations and resumed sessions

Author: alexylon

CHANGELOG.md

@@ -4,6 +4,12 @@ All notable changes to Sofos are documented in this file.
 
 ## [Unreleased]
 
+### Changed
+- Increase `MAX_TOOL_OUTPUT_TOKENS`
+
+### Fixed
+- Gracefully handle invalid image URLs in conversations and resumed sessions
+
 ## [0.1.19] - 2026-01-08
 
 ### Changed

src/repl/conversation.rs

@@ -275,6 +275,11 @@ Show imperial units only when the user explicitly asks for them."#,
         self.trim_if_needed();
     }
 
+    /// Remove the last message from the conversation (used for error recovery)
+    pub fn remove_last_message(&mut self) {
+        self.messages.pop();
+    }
+
     pub fn _len(&self) -> usize {
         self.messages.len()
     }

src/repl/mod.rs

@@ -382,6 +382,7 @@ impl Repl {
         });
 
         let client = self.client.clone();
+        let client_for_retry = client.clone();
         let req = initial_request;
         let mut request_handle = runtime.spawn(async move { client.create_message(req).await });
 
@@ -408,7 +409,95 @@ impl Repl {
             return Ok(());
         }
 
-        let response = response_result?;
+        // Handle API errors, especially those related to invalid images
+        let response = match response_result {
+            Ok(resp) => resp,
+            Err(e) => {
+                // Check if this is an image-related API error
+                if let SofosError::Api(ref msg) = e {
+                    let is_400_error = msg.contains("400");
+                    let is_image_error = msg.contains("Unable to download") 
+                        || msg.contains("invalid_request_error")
+                        || msg.contains("verify the URL");
+                    
+                    // Check if current message OR conversation has images
+                    let current_has_images = !image_refs.is_empty();
+                    let conversation_has_images = self.session_state.conversation.messages()
+                        .iter()
+                        .any(|msg| {
+                            use crate::api::{MessageContent, MessageContentBlock};
+                            if let MessageContent::Blocks { content } = &msg.content {
+                                content.iter().any(|block| matches!(block, MessageContentBlock::Image { .. }))
+                            } else {
+                                false
+                            }
+                        });
+                    
+                    let has_images = current_has_images || conversation_has_images;
+                    
+                    if is_400_error && is_image_error && has_images {
+                        println!(
+                            "\n{} {}\n",
+                            "⚠️  Image loading error:".bright_yellow().bold(),
+                            "One or more image URLs in the conversation could not be loaded by the API"
+                        );
+                        
+                        self.session_state.conversation.remove_last_message();
+                        
+                        // Remove ALL images from conversation
+                        let messages = self.session_state.conversation.messages();
+                        let mut cleaned_messages = Vec::new();
+                        
+                        for msg in messages {
+                            use crate::api::{Message, MessageContent, MessageContentBlock};
+                            let cleaned_msg = match &msg.content {
+                                MessageContent::Blocks { content } => {
+                                    let filtered_blocks: Vec<MessageContentBlock> = content
+                                        .iter()
+                                        .filter(|block| !matches!(block, MessageContentBlock::Image { .. }))
+                                        .cloned()
+                                        .collect();
+                                    
+                                    if filtered_blocks.is_empty() {
+                                        continue;
+                                    } else {
+                                        Message {
+                                            role: msg.role.clone(),
+                                            content: MessageContent::Blocks { content: filtered_blocks },
+                                        }
+                                    }
+                                }
+                                _ => msg.clone(),
+                            };
+                            cleaned_messages.push(cleaned_msg);
+                        }
+                        
+                        self.session_state.conversation.clear();
+                        self.session_state.conversation.restore_messages(cleaned_messages);
+                        
+                        let error_message = if !image_refs.is_empty() {
+                            "[SYSTEM ERROR: Image URLs in your message could not be loaded and have been removed from the conversation.]"
+                        } else {
+                            "[SYSTEM ERROR: Image URLs from a previous message could not be loaded and have been removed from the conversation. You can continue normally.]"
+                        }.to_string();
+                        
+                        self.session_state.conversation.add_user_message(error_message);
+                        let new_request = self.build_initial_request();
+                        
+                        println!("{}", "Retrying request without images...".dimmed());
+                        println!();
+                        
+                        runtime.block_on(async {
+                            client_for_retry.create_message(new_request).await
+                        })?
+                    } else {
+                        return Err(e);
+                    }
+                } else {
+                    return Err(e);
+                }
+            }
+        };
 
         self.session_state
             .add_tokens(response.usage.input_tokens, response.usage.output_tokens);

src/tools/bashexec.rs

@@ -6,7 +6,7 @@ use std::process::Command;
 use std::sync::{Arc, Mutex};
 
 const MAX_OUTPUT_SIZE: usize = 10 * 1024 * 1024; // 10MB limit
-const MAX_TOOL_OUTPUT_TOKENS: usize = 8_000; // ~28KB, prevents excessive context usage
+const MAX_TOOL_OUTPUT_TOKENS: usize = 16_000; // ~56KB, prevents excessive context usage
 
 /// Truncate bash output if it exceeds token limit for context efficiency
 fn truncate_for_context(content: &str, max_tokens: usize) -> String {

src/tools/filesystem.rs

@@ -4,7 +4,7 @@ use std::fs;
 use std::path::{Path, PathBuf};
 
 const MAX_FILE_SIZE: u64 = 50 * 1024 * 1024; // 50MB limit
-const MAX_TOOL_OUTPUT_TOKENS: usize = 8_000; // ~28KB, prevents excessive context usage
+const MAX_TOOL_OUTPUT_TOKENS: usize = 16_000; // ~56KB, prevents excessive context usage
 
 /// Truncate file content if it exceeds token limit for context efficiency
 fn truncate_for_context(content: &str, max_tokens: usize) -> String {