chat-console 0.3.6__py3-none-any.whl → 0.3.8__py3-none-any.whl

app/__init__.py

@@ -3,4 +3,4 @@ Chat CLI
 A command-line interface for chatting with various LLM providers like ChatGPT and Claude.
 """
 
-__version__ = "0.3.6"
+__version__ = "0.3.8"

app/api/base.py

@@ -38,27 +38,41 @@ class BaseModelClient(ABC):
         
         logger = logging.getLogger(__name__)
         
+        # Safety check for None or empty string
+        if not model_name:
+            logger.warning("Empty model name passed to get_client_type_for_model")
+            return None
+            
         # Get model info and provider
         model_info = CONFIG["available_models"].get(model_name)
         model_name_lower = model_name.lower()
         
+        # Debug log the model name
+        logger.info(f"Getting client type for model: {model_name}")
+        
         # If model is in config, use its provider
         if model_info:
             provider = model_info["provider"]
+            logger.info(f"Found model in config with provider: {provider}")
         # For custom models, try to infer provider
         else:
-            # First try Ollama for known model names or if selected from Ollama UI
-            if (any(name in model_name_lower for name in ["llama", "mistral", "codellama", "gemma"]) or
-                model_name in [m["id"] for m in CONFIG.get("ollama_models", [])]):
-                provider = "ollama"
-            # Then try other providers
-            elif any(name in model_name_lower for name in ["gpt", "text-", "davinci"]):
+            # First check for OpenAI models - these should ALWAYS use OpenAI client
+            if any(name in model_name_lower for name in ["gpt", "text-", "davinci"]):
                 provider = "openai"
+                logger.info(f"Identified as OpenAI model: {model_name}")
+            # Then check for Anthropic models - these should ALWAYS use Anthropic client
             elif any(name in model_name_lower for name in ["claude", "anthropic"]):
                 provider = "anthropic"
+                logger.info(f"Identified as Anthropic model: {model_name}")
+            # Then try Ollama for known model names or if selected from Ollama UI
+            elif (any(name in model_name_lower for name in ["llama", "mistral", "codellama", "gemma"]) or
+                  model_name in [m["id"] for m in CONFIG.get("ollama_models", [])]):
+                provider = "ollama"
+                logger.info(f"Identified as Ollama model: {model_name}")
             else:
                 # Default to Ollama for unknown models
                 provider = "ollama"
+                logger.info(f"Unknown model type, defaulting to Ollama: {model_name}")
         
         # Return appropriate client class
         if provider == "ollama":
@@ -81,6 +95,14 @@ class BaseModelClient(ABC):
         
         logger = logging.getLogger(__name__)
         
+        # Safety check for None or empty string
+        if not model_name:
+            logger.warning("Empty model name passed to get_client_for_model")
+            raise ValueError("Model name cannot be empty")
+            
+        # Log the model name we're getting a client for
+        logger.info(f"Getting client for model: {model_name}")
+        
         # Get model info and provider
         model_info = CONFIG["available_models"].get(model_name)
         model_name_lower = model_name.lower()
@@ -88,31 +110,35 @@ class BaseModelClient(ABC):
         # If model is in config, use its provider
         if model_info:
             provider = model_info["provider"]
+            logger.info(f"Found model in config with provider: {provider}")
             if not AVAILABLE_PROVIDERS[provider]:
                 raise Exception(f"Provider '{provider}' is not available. Please check your configuration.")
         # For custom models, try to infer provider
         else:
-            # First try Ollama for known model names or if selected from Ollama UI
-            if (any(name in model_name_lower for name in ["llama", "mistral", "codellama", "gemma"]) or
-                model_name in [m["id"] for m in CONFIG.get("ollama_models", [])]):
-                if not AVAILABLE_PROVIDERS["ollama"]:
-                    raise Exception("Ollama server is not running. Please start Ollama and try again.")
-                provider = "ollama"
-                logger.info(f"Using Ollama for model: {model_name}")
-            # Then try other providers if they're available
-            elif any(name in model_name_lower for name in ["gpt", "text-", "davinci"]):
+            # First check for OpenAI models - these should ALWAYS use OpenAI client
+            if any(name in model_name_lower for name in ["gpt", "text-", "davinci"]):
                 if not AVAILABLE_PROVIDERS["openai"]:
                     raise Exception("OpenAI API key not found. Please set OPENAI_API_KEY environment variable.")
                 provider = "openai"
+                logger.info(f"Identified as OpenAI model: {model_name}")
+            # Then check for Anthropic models - these should ALWAYS use Anthropic client
             elif any(name in model_name_lower for name in ["claude", "anthropic"]):
                 if not AVAILABLE_PROVIDERS["anthropic"]:
                     raise Exception("Anthropic API key not found. Please set ANTHROPIC_API_KEY environment variable.")
                 provider = "anthropic"
+                logger.info(f"Identified as Anthropic model: {model_name}")
+            # Then try Ollama for known model names or if selected from Ollama UI
+            elif (any(name in model_name_lower for name in ["llama", "mistral", "codellama", "gemma"]) or
+                  model_name in [m["id"] for m in CONFIG.get("ollama_models", [])]):
+                if not AVAILABLE_PROVIDERS["ollama"]:
+                    raise Exception("Ollama server is not running. Please start Ollama and try again.")
+                provider = "ollama"
+                logger.info(f"Identified as Ollama model: {model_name}")
             else:
                 # Default to Ollama for unknown models
                 if AVAILABLE_PROVIDERS["ollama"]:
                     provider = "ollama"
-                    logger.info(f"Defaulting to Ollama for unknown model: {model_name}")
+                    logger.info(f"Unknown model type, defaulting to Ollama: {model_name}")
                 else:
                     raise Exception(f"Unknown model: {model_name}")
         

app/main.py

@@ -707,10 +707,18 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
                         else:
                             raise Exception("No valid API clients available for title generation")
 
-                # Generate title
+                # Generate title - make sure we're using the right client for the model
                 print(f"Calling generate_conversation_title with model: {model}")
                 log(f"Calling generate_conversation_title with model: {model}")
-                debug_log(f"Calling generate_conversation_title with model: {model}")
+                debug_log(f"Calling generate_conversation_title with model: {model}, client type: {type(client).__name__}")
+                
+                # Double-check that we're using the right client for this model
+                expected_client_type = BaseModelClient.get_client_type_for_model(model)
+                if expected_client_type and not isinstance(client, expected_client_type):
+                    debug_log(f"Warning: Client type mismatch. Expected {expected_client_type.__name__}, got {type(client).__name__}")
+                    debug_log("Creating new client with correct type")
+                    client = await BaseModelClient.get_client_for_model(model)
+                
                 title = await generate_conversation_title(content, model, client)
                 debug_log(f"Generated title: {title}")
                 log(f"Generated title: {title}")
@@ -729,11 +737,9 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
                 # Update conversation object
                 self.current_conversation.title = title
                 
-                # IMPORTANT: Save the successful model for consistency
-                # If the title was generated with a different model than initially selected,
-                # update the selected_model to match so the response uses the same model
-                debug_log(f"Using same model for chat response: '{model}'")
-                self.selected_model = model
+                # DO NOT update the selected model here - keep the user's original selection
+                # This was causing issues with model mixing
+                debug_log(f"Keeping original selected model: '{self.selected_model}'")
 
                 self.notify(f"Conversation title set to: {title}", severity="information", timeout=3)
 
@@ -805,17 +811,23 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
             style = self.selected_style
             
             debug_log(f"Using model: '{model}', style: '{style}'")
+            
+            # Determine the expected client type for this model
+            expected_client_type = BaseModelClient.get_client_type_for_model(model)
+            debug_log(f"Expected client type for {model}: {expected_client_type.__name__ if expected_client_type else 'None'}")
 
             # Ensure we have a valid model
             if not model:
                 debug_log("Model is empty, selecting a default model")
-                # Same fallback logic as in autotitling - this ensures consistency
+                # Check which providers are available and select an appropriate default
                 if OPENAI_API_KEY:
                     model = "gpt-3.5-turbo"
-                    debug_log("Falling back to OpenAI gpt-3.5-turbo")
+                    expected_client_type = BaseModelClient.get_client_type_for_model(model)
+                    debug_log(f"Falling back to OpenAI gpt-3.5-turbo with client type {expected_client_type.__name__ if expected_client_type else 'None'}")
                 elif ANTHROPIC_API_KEY:
-                    model = "claude-instant-1.2"
-                    debug_log("Falling back to Anthropic claude-instant-1.2")
+                    model = "claude-3-haiku-20240307"  # Updated to newer Claude model
+                    expected_client_type = BaseModelClient.get_client_type_for_model(model)
+                    debug_log(f"Falling back to Anthropic Claude 3 Haiku with client type {expected_client_type.__name__ if expected_client_type else 'None'}")
                 else:
                     # Check for a common Ollama model
                     try:
@@ -826,11 +838,13 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
                             model = models[0].get("id", "llama3")
                         else:
                             model = "llama3"  # Common default
-                        debug_log(f"Falling back to Ollama model: {model}")
+                        expected_client_type = BaseModelClient.get_client_type_for_model(model)
+                        debug_log(f"Falling back to Ollama model: {model} with client type {expected_client_type.__name__ if expected_client_type else 'None'}")
                     except Exception as ollama_err:
                         debug_log(f"Error getting Ollama models: {str(ollama_err)}")
                         model = "llama3"  # Final fallback
-                        debug_log("Final fallback to llama3")
+                        expected_client_type = BaseModelClient.get_client_type_for_model(model)
+                        debug_log(f"Final fallback to llama3 with client type {expected_client_type.__name__ if expected_client_type else 'None'}")
 
             # Convert messages to API format with enhanced error checking
             api_messages = []
@@ -926,27 +940,39 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
             last_refresh_time = time.time()  # Initialize refresh throttling timer
 
             async def update_ui(content: str):
-                # This function remains the same, called by the worker
+                # This function is called by the worker with each content update
                 if not self.is_generating:
                     debug_log("update_ui called but is_generating is False, returning.")
                     return
                 
                 async with update_lock:
                     try:
+                        # Add more verbose logging
+                        debug_log(f"update_ui called with content length: {len(content)}")
+                        print(f"update_ui: Updating with content length {len(content)}")
+                        
                         # Clear thinking indicator on first content
                         if assistant_message.content == "Thinking...":
                             debug_log("First content received, clearing 'Thinking...'")
                             print("First content received, clearing 'Thinking...'")
-                            assistant_message.content = ""
-
+                            # We'll let the MessageDisplay.update_content handle this special case
+                        
                         # Update the message object with the full content
                         assistant_message.content = content
 
-                        # Update UI with the content
+                        # Update UI with the content - this now has special handling for "Thinking..."
+                        debug_log("Calling message_display.update_content")
                         await message_display.update_content(content)
                         
-                        # Simple refresh approach - just force a layout refresh
+                        # More aggressive UI refresh sequence
+                        debug_log("Performing UI refresh sequence")
+                        # First do a lightweight refresh
+                        self.refresh(layout=False)
+                        # Then scroll to end
+                        messages_container.scroll_end(animate=False)
+                        # Then do a full layout refresh
                         self.refresh(layout=True)
+                        # Final scroll to ensure visibility
                         messages_container.scroll_end(animate=False)
                         
                     except Exception as e:
@@ -1016,14 +1042,32 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
                 error = worker.error
                 debug_log(f"Error in generation worker: {error}")
                 log.error(f"Error in generation worker: {error}")
-                self.notify(f"Generation error: {error}", severity="error", timeout=5)
+                
+                # Sanitize error message for UI display
+                error_str = str(error)
+                
+                # Check if this is an Ollama error
+                is_ollama_error = "ollama" in error_str.lower() or "404" in error_str
+                
+                # Create a user-friendly error message
+                if is_ollama_error:
+                    # For Ollama errors, provide a more user-friendly message
+                    user_error = "Unable to generate response. The selected model may not be available."
+                    debug_log(f"Sanitizing Ollama error to user-friendly message: {user_error}")
+                    # Show technical details only in notification, not in chat
+                    self.notify(f"Model error: {error_str}", severity="error", timeout=5)
+                else:
+                    # For other errors, show a generic message
+                    user_error = f"Error generating response: {error_str}"
+                    self.notify(f"Generation error: {error_str}", severity="error", timeout=5)
+                
                 # Add error message to UI
                 if self.messages and self.messages[-1].role == "assistant":
                     debug_log("Removing thinking message")
                     self.messages.pop()  # Remove thinking message
-                error_msg = f"Error: {error}"
-                debug_log(f"Adding error message: {error_msg}")
-                self.messages.append(Message(role="assistant", content=error_msg))
+                
+                debug_log(f"Adding error message: {user_error}")
+                self.messages.append(Message(role="assistant", content=user_error))
                 await self.update_messages_ui()
 
             elif worker.state == "success":

app/ui/chat_interface.py

@@ -121,11 +121,23 @@ class MessageDisplay(Static): # Inherit from Static instead of RichLog
         
     async def update_content(self, content: str) -> None:
         """Update the message content using Static.update() with optimizations for streaming"""
+        # Debug print to verify method is being called with content
+        print(f"MessageDisplay.update_content called with content length: {len(content)}")
+        
         # Quick unchanged content check to avoid unnecessary updates
         if self.message.content == content:
+            print("Content unchanged, skipping update")
             return
             
-        # Update the stored message object content first
+        # Special handling for "Thinking..." to ensure it gets replaced
+        if self.message.content == "Thinking..." and content:
+            print("Replacing 'Thinking...' with actual content")
+            # Force a complete replacement rather than an append
+            self.message.content = ""
+            # Add a debug print to confirm this branch is executed
+            print("CRITICAL FIX: Replacing 'Thinking...' placeholder with actual content")
+            
+        # Update the stored message object content
         self.message.content = content
         
         # Format with fixed-width placeholder to minimize layout shifts
@@ -134,6 +146,7 @@ class MessageDisplay(Static): # Inherit from Static instead of RichLog
         
         # Use a direct update that forces refresh - critical fix for streaming
         # This ensures content is immediately visible
+        print(f"Updating widget with formatted content length: {len(formatted_content)}")
         self.update(formatted_content, refresh=True)
         
         # Force app-level refresh and scroll to ensure visibility
@@ -148,6 +161,9 @@ class MessageDisplay(Static): # Inherit from Static instead of RichLog
                 for container in containers:
                     if hasattr(container, 'scroll_end'):
                         container.scroll_end(animate=False)
+                        
+                # Add an additional refresh after scrolling
+                self.app.refresh(layout=True)
         except Exception as e:
             # Log the error and fallback to local refresh
             print(f"Error refreshing app: {str(e)}")
@@ -157,6 +173,11 @@ class MessageDisplay(Static): # Inherit from Static instead of RichLog
         """Format message content with timestamp and handle markdown links"""
         timestamp = datetime.now().strftime("%H:%M")
         
+        # Special handling for "Thinking..." to make it visually distinct
+        if content == "Thinking...":
+            # Use italic style for the thinking indicator
+            return f"[dim]{timestamp}[/dim] [italic]{content}[/italic]"
+            
         # Fix markdown-style links that cause markup errors
         # Convert [text](url) to a safe format for Textual markup
         content = re.sub(

app/utils.py

@@ -20,33 +20,108 @@ logger = logging.getLogger(__name__)
 
 async def generate_conversation_title(message: str, model: str, client: Any) -> str:
     """Generate a descriptive title for a conversation based on the first message"""
+    try:
+        from app.main import debug_log
+    except ImportError:
+        debug_log = lambda msg: None
+    
+    debug_log(f"Starting title generation with model: {model}, client type: {type(client).__name__}")
+    
     # --- Choose a specific, reliable model for title generation ---
-    # Prefer Haiku if Anthropic is available, otherwise fallback
+    # First, determine if we have a valid client
+    if client is None:
+        debug_log("Client is None, will use default title")
+        return f"Conversation ({datetime.now().strftime('%Y-%m-%d %H:%M')})"
+    
+    # Determine the best model to use for title generation
     title_model_id = None
-    if client and isinstance(client, anthropic.AsyncAnthropic): # Check if the passed client is Anthropic
-        # Check if Haiku is listed in the client's available models (more robust)
-        available_anthropic_models = client.get_available_models()
-        haiku_id = "claude-3-haiku-20240307"
-        if any(m["id"] == haiku_id for m in available_anthropic_models):
-             title_model_id = haiku_id
-             logger.info(f"Using Anthropic Haiku for title generation: {title_model_id}")
-        else:
-             # If Haiku not found, try Sonnet
-             sonnet_id = "claude-3-sonnet-20240229"
-             if any(m["id"] == sonnet_id for m in available_anthropic_models):
-                  title_model_id = sonnet_id
-                  logger.info(f"Using Anthropic Sonnet for title generation: {title_model_id}")
-             else:
-                  logger.warning(f"Neither Haiku nor Sonnet found in Anthropic client's list. Falling back.")
-
-    # Fallback logic if no specific Anthropic model was found or client is not Anthropic
+    
+    # Check if client is Anthropic
+    is_anthropic = 'anthropic' in str(type(client)).lower()
+    if is_anthropic:
+        debug_log("Using Anthropic client for title generation")
+        # Try to get available models safely
+        try:
+            available_anthropic_models = client.get_available_models()
+            debug_log(f"Found {len(available_anthropic_models)} Anthropic models")
+            
+            # Try Claude 3 Haiku first (fastest)
+            haiku_id = "claude-3-haiku-20240307"
+            if any(m.get("id") == haiku_id for m in available_anthropic_models):
+                title_model_id = haiku_id
+                debug_log(f"Using Anthropic Haiku for title generation: {title_model_id}")
+            else:
+                # If Haiku not found, try Sonnet
+                sonnet_id = "claude-3-sonnet-20240229"
+                if any(m.get("id") == sonnet_id for m in available_anthropic_models):
+                    title_model_id = sonnet_id
+                    debug_log(f"Using Anthropic Sonnet for title generation: {title_model_id}")
+                else:
+                    debug_log("Neither Haiku nor Sonnet found in Anthropic models list")
+        except Exception as e:
+            debug_log(f"Error getting Anthropic models: {str(e)}")
+
+    # Check if client is OpenAI
+    is_openai = 'openai' in str(type(client)).lower()
+    if is_openai:
+        debug_log("Using OpenAI client for title generation")
+        # Use GPT-3.5 for title generation (fast and cost-effective)
+        title_model_id = "gpt-3.5-turbo"
+        debug_log(f"Using OpenAI model for title generation: {title_model_id}")
+        # For OpenAI, we'll always use their model, not fall back to the passed model
+        # This prevents trying to use Ollama models with OpenAI client
+    
+    # Check if client is Ollama
+    is_ollama = 'ollama' in str(type(client)).lower()
+    if is_ollama and not title_model_id:
+        debug_log("Using Ollama client for title generation")
+        # For Ollama, check if the model exists before using it
+        try:
+            # Try a quick test request to check if model exists
+            debug_log(f"Testing if Ollama model exists: {model}")
+            import aiohttp
+            async with aiohttp.ClientSession() as session:
+                try:
+                    base_url = "http://localhost:11434"
+                    async with session.post(
+                        f"{base_url}/api/generate",
+                        json={"model": model, "prompt": "test", "stream": False},
+                        timeout=2
+                    ) as response:
+                        if response.status == 200:
+                            # Model exists, use it
+                            title_model_id = model
+                            debug_log(f"Ollama model {model} exists, using it for title generation")
+                        else:
+                            debug_log(f"Ollama model {model} returned status {response.status}, falling back to default")
+                            # Fall back to a common model
+                            title_model_id = "llama3"
+                except Exception as e:
+                    debug_log(f"Error testing Ollama model: {str(e)}, falling back to default")
+                    # Fall back to a common model
+                    title_model_id = "llama3"
+        except Exception as e:
+            debug_log(f"Error checking Ollama model: {str(e)}")
+            # Fall back to a common model
+            title_model_id = "llama3"
+    
+    # Fallback logic if no specific model was found
     if not title_model_id:
-        # Use the originally passed model (user's selected chat model) as the final fallback
-        title_model_id = model
-        logger.warning(f"Falling back to originally selected model for title generation: {title_model_id}")
-        # Consider adding fallbacks to OpenAI/Ollama here if needed based on config/availability
-
+        # Use a safe default based on client type
+        if is_openai:
+            title_model_id = "gpt-3.5-turbo"
+        elif is_anthropic:
+            title_model_id = "claude-3-haiku-20240307"
+        elif is_ollama:
+            title_model_id = "llama3"  # Common default
+        else:
+            # Last resort - use the originally passed model
+            title_model_id = model
+        
+        debug_log(f"No specific model found, using fallback model for title generation: {title_model_id}")
+    
     logger.info(f"Generating title for conversation using model: {title_model_id}")
+    debug_log(f"Final model selected for title generation: {title_model_id}")
 
     # Create a special prompt for title generation
     title_prompt = [
@@ -65,36 +140,44 @@ async def generate_conversation_title(message: str, model: str, client: Any) ->
     
     while tries > 0:
         try:
-            # Generate a title using the same model but with a separate request
-            # Assuming client has a method like generate_completion or similar
-            # Adjust the method call based on the actual client implementation
+            debug_log(f"Attempt {3-tries} to generate title")
+            # First try generate_completion if available
             if hasattr(client, 'generate_completion'):
-                title = await client.generate_completion(
-                    messages=title_prompt,
-                    model=title_model_id, # Use the chosen title model
-                    temperature=0.7,
-                    max_tokens=60  # Titles should be short
-                )
-            elif hasattr(client, 'generate_stream'): # Fallback or alternative method?
-                 # If generate_completion isn't available, maybe adapt generate_stream?
-                 # This part needs clarification based on the client's capabilities.
-                 # For now, let's assume a hypothetical non-streaming call or adapt stream
-                 # Simplified adaptation: collect stream chunks
-                 title_chunks = []
-                 try:
-                     # Use the chosen title model here too
-                     async for chunk in client.generate_stream(title_prompt, title_model_id, style=""):
-                         if chunk is not None:  # Ensure we only process non-None chunks
-                             title_chunks.append(chunk)
-                     title = "".join(title_chunks)
-                     # If we didn't get any content, use a default
-                     if not title.strip():
-                         title = f"Conversation ({datetime.now().strftime('%Y-%m-%d %H:%M')})"
-                 except Exception as stream_error:
-                     logger.error(f"Error during title stream processing: {str(stream_error)}")
-                     title = f"Conversation ({datetime.now().strftime('%Y-%m-%d %H:%M')})"
+                debug_log("Using generate_completion method")
+                try:
+                    title = await client.generate_completion(
+                        messages=title_prompt,
+                        model=title_model_id,
+                        temperature=0.7,
+                        max_tokens=60  # Titles should be short
+                    )
+                    debug_log(f"Title generated successfully: {title}")
+                except Exception as completion_error:
+                    debug_log(f"Error in generate_completion: {str(completion_error)}")
+                    raise  # Re-raise to be caught by outer try/except
+            # Fall back to generate_stream if completion not available
+            elif hasattr(client, 'generate_stream'):
+                debug_log("Using generate_stream method")
+                title_chunks = []
+                try:
+                    async for chunk in client.generate_stream(title_prompt, title_model_id, style=""):
+                        if chunk is not None:
+                            title_chunks.append(chunk)
+                            debug_log(f"Received chunk of length: {len(chunk)}")
+                    
+                    title = "".join(title_chunks)
+                    debug_log(f"Combined title from chunks: {title}")
+                    
+                    # If we didn't get any content, use a default
+                    if not title.strip():
+                        debug_log("Empty title received, using default")
+                        title = f"Conversation ({datetime.now().strftime('%Y-%m-%d %H:%M')})"
+                except Exception as stream_error:
+                    debug_log(f"Error during title stream processing: {str(stream_error)}")
+                    raise  # Re-raise to be caught by outer try/except
             else:
-                 raise NotImplementedError("Client does not support a suitable method for title generation.")
+                debug_log("Client does not support any title generation method")
+                raise NotImplementedError("Client does not support a suitable method for title generation.")
 
             # Sanitize and limit the title
             title = title.strip().strip('"\'').strip()
@@ -102,20 +185,23 @@ async def generate_conversation_title(message: str, model: str, client: Any) ->
                 title = title[:37] + "..."
                 
             logger.info(f"Generated title: {title}")
-            return title # Return successful title
+            debug_log(f"Final sanitized title: {title}")
+            return title  # Return successful title
             
         except Exception as e:
             last_error = str(e)
-            logger.error(f"Error generating title (tries left: {tries - 1}): {last_error}")
+            debug_log(f"Error generating title (tries left: {tries-1}): {last_error}")
+            logger.error(f"Error generating title (tries left: {tries-1}): {last_error}")
             tries -= 1
-            if tries > 0: # Only sleep if there are more retries
+            if tries > 0:  # Only sleep if there are more retries
                 await asyncio.sleep(1)  # Small delay before retry
     
-    # If all retries fail, log the last error and return a default title
+    # If all retries fail, log the error and return a default title
+    debug_log(f"Failed to generate title after multiple retries. Using default title.")
     logger.error(f"Failed to generate title after multiple retries. Last error: {last_error}")
     return f"Conversation ({datetime.now().strftime('%Y-%m-%d %H:%M')})"
 
-# Make this the worker function directly
+# Worker function for streaming response generation
 async def generate_streaming_response(
     app: 'SimpleChatApp',
     messages: List[Dict],
@@ -136,10 +222,12 @@ async def generate_streaming_response(
     logger.info(f"Starting streaming response with model: {model}")
     debug_log(f"Starting streaming response with model: '{model}', client type: {type(client).__name__}")
 
+    # Validate messages
     if not messages:
         debug_log("Error: messages list is empty")
         raise ValueError("Messages list cannot be empty")
 
+    # Ensure all messages have required fields
     for i, msg in enumerate(messages):
         try:
             debug_log(f"Message {i}: role={msg.get('role', 'missing')}, content_len={len(msg.get('content', ''))}")
@@ -157,14 +245,14 @@ async def generate_streaming_response(
             }
             debug_log(f"Repaired message {i}")
 
-    import time
-
+    # Initialize variables for response tracking
     full_response = ""
     buffer = []
     last_update = time.time()
     update_interval = 0.05  # Reduced interval for more frequent updates
 
     try:
+        # Validate client
         if client is None:
             debug_log("Error: client is None, cannot proceed with streaming")
             raise ValueError("Model client is None, cannot proceed with streaming")
@@ -173,9 +261,15 @@ async def generate_streaming_response(
             debug_log(f"Error: client {type(client).__name__} does not have generate_stream method")
             raise ValueError(f"Client {type(client).__name__} does not support streaming")
 
+        # Determine client type
         is_ollama = 'ollama' in str(type(client)).lower()
-        debug_log(f"Is Ollama client: {is_ollama}")
+        is_openai = 'openai' in str(type(client)).lower()
+        is_anthropic = 'anthropic' in str(type(client)).lower()
+        
+        debug_log(f"Client types - Ollama: {is_ollama}, OpenAI: {is_openai}, Anthropic: {is_anthropic}")
 
+        # Only show loading indicator for Ollama (which may need to load models)
+        # This prevents Ollama-specific UI elements from showing when using other providers
         if is_ollama and hasattr(app, 'query_one'):
             try:
                 debug_log("Showing initial model loading indicator for Ollama")
@@ -190,6 +284,7 @@ async def generate_streaming_response(
         debug_log(f"Starting stream generation with messages length: {len(messages)}")
         logger.info(f"Starting stream generation for model: {model}")
 
+        # Initialize stream generator
         try:
             debug_log("Calling client.generate_stream()")
             stream_generator = client.generate_stream(messages, model, style)
@@ -199,10 +294,12 @@ async def generate_streaming_response(
             logger.error(f"Error initializing stream generator: {str(stream_init_error)}")
             raise
 
-        if hasattr(client, 'is_loading_model') and not client.is_loading_model() and hasattr(app, 'query_one'):
+        # Update UI if model is ready (Ollama specific)
+        # Only check is_loading_model for Ollama clients to prevent errors with other providers
+        if is_ollama and hasattr(client, 'is_loading_model') and not client.is_loading_model() and hasattr(app, 'query_one'):
             try:
-                debug_log("Model is ready for generation, updating UI")
-                logger.info("Model is ready for generation, updating UI")
+                debug_log("Ollama model is ready for generation, updating UI")
+                logger.info("Ollama model is ready for generation, updating UI")
                 loading = app.query_one("#loading-indicator")
                 loading.remove_class("model-loading")
                 loading.update("▪▪▪ Generating response...")
@@ -210,9 +307,11 @@ async def generate_streaming_response(
                 debug_log(f"Error updating UI after stream init: {str(e)}")
                 logger.error(f"Error updating UI after stream init: {str(e)}")
 
+        # Process stream chunks
         debug_log("Beginning to process stream chunks")
         try:
             async for chunk in stream_generator:
+                # Check for task cancellation
                 if asyncio.current_task().cancelled():
                     debug_log("Task cancellation detected during chunk processing")
                     logger.info("Task cancellation detected during chunk processing")
@@ -221,30 +320,32 @@ async def generate_streaming_response(
                         await client.cancel_stream()
                     raise asyncio.CancelledError()
 
-                if hasattr(client, 'is_loading_model'):
+                # Handle Ollama model loading state changes - only for Ollama clients
+                if is_ollama and hasattr(client, 'is_loading_model'):
                     try:
                         model_loading = client.is_loading_model()
-                        debug_log(f"Model loading state: {model_loading}")
+                        debug_log(f"Ollama model loading state: {model_loading}")
                         if hasattr(app, 'query_one'):
                             try:
                                 loading = app.query_one("#loading-indicator")
                                 if model_loading and hasattr(loading, 'has_class') and not loading.has_class("model-loading"):
-                                    debug_log("Model loading started during streaming")
-                                    logger.info("Model loading started during streaming")
+                                    debug_log("Ollama model loading started during streaming")
+                                    logger.info("Ollama model loading started during streaming")
                                     loading.add_class("model-loading")
                                     loading.update("⚙️ Loading Ollama model...")
                                 elif not model_loading and hasattr(loading, 'has_class') and loading.has_class("model-loading"):
-                                    debug_log("Model loading finished during streaming")
-                                    logger.info("Model loading finished during streaming")
+                                    debug_log("Ollama model loading finished during streaming")
+                                    logger.info("Ollama model loading finished during streaming")
                                     loading.remove_class("model-loading")
                                     loading.update("▪▪▪ Generating response...")
                             except Exception as ui_e:
                                 debug_log(f"Error updating UI elements: {str(ui_e)}")
                                 logger.error(f"Error updating UI elements: {str(ui_e)}")
                     except Exception as e:
-                        debug_log(f"Error checking model loading state: {str(e)}")
-                        logger.error(f"Error checking model loading state: {str(e)}")
+                        debug_log(f"Error checking Ollama model loading state: {str(e)}")
+                        logger.error(f"Error checking Ollama model loading state: {str(e)}")
 
+                # Process chunk content
                 if chunk:
                     if not isinstance(chunk, str):
                         debug_log(f"WARNING: Received non-string chunk of type: {type(chunk).__name__}")
@@ -259,7 +360,8 @@ async def generate_streaming_response(
                     buffer.append(chunk)
                     current_time = time.time()
 
-                    # Always update immediately for the first few chunks
+                    # Update UI with new content
+                    # Always update immediately for the first few chunks for better responsiveness
                     if (current_time - last_update >= update_interval or
                         len(''.join(buffer)) > 5 or  # Reduced buffer size threshold
                         len(full_response) < 50):    # More aggressive updates for early content
@@ -268,25 +370,26 @@ async def generate_streaming_response(
                         full_response += new_content
                         debug_log(f"Updating UI with content length: {len(full_response)}")
                         
-                        # Print to console for debugging
-                        print(f"Streaming update: +{len(new_content)} chars, total: {len(full_response)}")
+                        # Enhanced debug logging
+                        print(f"STREAM DEBUG: +{len(new_content)} chars, total: {len(full_response)}")
+                        # Print first few characters of content for debugging
+                        if len(full_response) < 100:
+                            print(f"STREAM CONTENT: '{full_response}'")
                         
                         try:
                             # Call the UI callback with the full response so far
+                            debug_log("Calling UI callback with content")
                             await callback(full_response)
                             debug_log("UI callback completed successfully")
                             
                             # Force app refresh after each update
                             if hasattr(app, 'refresh'):
+                                debug_log("Forcing app refresh")
                                 app.refresh(layout=True)  # Force layout refresh
                         except Exception as callback_err:
                             debug_log(f"Error in UI callback: {str(callback_err)}")
                             logger.error(f"Error in UI callback: {str(callback_err)}")
-                            print(f"Error updating UI: {str(callback_err)}")
-                        except Exception as callback_err:
-                            debug_log(f"Error in UI callback: {str(callback_err)}")
-                            logger.error(f"Error in UI callback: {str(callback_err)}")
-                            print(f"Error updating UI: {str(callback_err)}")
+                            print(f"STREAM ERROR: Error updating UI: {str(callback_err)}")
                             
                         buffer = []
                         last_update = current_time
@@ -442,8 +545,8 @@ def resolve_model_id(model_id_or_name: str) -> str:
     """
     Resolves a potentially short model ID or display name to the full model ID
     stored in the configuration. Tries multiple matching strategies.
-
-    Fix: Only apply dot-to-colon conversion for Ollama models, not for OpenAI/Anthropic/custom.
+    
+    This function is critical for ensuring models are correctly identified by provider.
     """
     if not model_id_or_name:
         logger.warning("resolve_model_id called with empty input, returning empty string.")
@@ -451,6 +554,16 @@ def resolve_model_id(model_id_or_name: str) -> str:
 
     input_lower = model_id_or_name.lower().strip()
     logger.info(f"Attempting to resolve model identifier: '{input_lower}'")
+    
+    # First, check if this is an OpenAI model - if so, return as-is to ensure correct provider
+    if any(name in input_lower for name in ["gpt", "text-", "davinci"]):
+        logger.info(f"Input '{input_lower}' appears to be an OpenAI model, returning as-is")
+        return model_id_or_name
+        
+    # Next, check if this is an Anthropic model - if so, return as-is to ensure correct provider
+    if any(name in input_lower for name in ["claude", "anthropic"]):
+        logger.info(f"Input '{input_lower}' appears to be an Anthropic model, returning as-is")
+        return model_id_or_name
 
     available_models = CONFIG.get("available_models", {})
     if not available_models:
@@ -461,20 +574,22 @@ def resolve_model_id(model_id_or_name: str) -> str:
     provider = None
     if input_lower in available_models:
         provider = available_models[input_lower].get("provider")
+        logger.info(f"Found model in available_models with provider: {provider}")
     else:
         # Try to find by display name
         for model_info in available_models.values():
             if model_info.get("display_name", "").lower() == input_lower:
                 provider = model_info.get("provider")
+                logger.info(f"Found model by display name with provider: {provider}")
                 break
 
     # Special case for Ollama models with version format (model:version)
-    if provider == "ollama" and ":" in input_lower and not input_lower.startswith("claude-"):
+    if (provider == "ollama" or any(name in input_lower for name in ["llama", "mistral", "codellama", "gemma"])) and ":" in input_lower and not input_lower.startswith("claude-"):
         logger.info(f"Input '{input_lower}' appears to be an Ollama model with version, returning as-is")
         return model_id_or_name
 
     # Only apply dot-to-colon for Ollama models
-    if provider == "ollama" and "." in input_lower and not input_lower.startswith("claude-"):
+    if (provider == "ollama" or any(name in input_lower for name in ["llama", "mistral", "codellama", "gemma"])) and "." in input_lower and not input_lower.startswith("claude-"):
         logger.info(f"Input '{input_lower}' appears to be an Ollama model with dot notation")
         if ":" not in input_lower:
             parts = input_lower.split(".")

{chat_console-0.3.6.dist-info → chat_console-0.3.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chat-console
-Version: 0.3.6
+Version: 0.3.8
 Summary: A command-line interface for chatting with LLMs, storing chats and (future) rag interactions
 Home-page: https://github.com/wazacraftrfid/chat-console
 Author: Johnathan Greenaway

{chat_console-0.3.6.dist-info → chat_console-0.3.8.dist-info}/RECORD

@@ -1,24 +1,24 @@
-app/__init__.py,sha256=wUvsU30dqInIPNxEtkmKfV3elJ3g5-yEF367L06eu6E,130
+app/__init__.py,sha256=GakIrISWzWywKWxN4zYsAXUif2gEnmhI_aZfkWRzDJI,130
 app/config.py,sha256=KawltE7cK2bR9wbe1NSlepwWIjkiFw2bg3vbLmUnP38,7626
 app/database.py,sha256=nt8CVuDpy6zw8mOYqDcfUmNw611t7Ln7pz22M0b6-MI,9967
-app/main.py,sha256=aGCaQYBTgV6PRgv6ZngC-bOYAtPl8O-9V_cMOionqbk,71245
+app/main.py,sha256=KEkM7wMG7gQ4jFTRNWTTm7HQL5av6fVHFzg-uFyroZw,74654
 app/models.py,sha256=4-y9Lytay2exWPFi0FDlVeRL3K2-I7E-jBqNzTfokqY,2644
-app/utils.py,sha256=1eiwjQwZRJIaZvUPQVUmTpyEvWUh3iiKeX-vRRgyUGs,28925
+app/utils.py,sha256=u4Og-N9EKHuhI81PHlPQkdpetIR1zX3UBTZ5XssvowI,34659
 app/api/__init__.py,sha256=A8UL84ldYlv8l7O-yKzraVFcfww86SgWfpl4p7R03-w,62
 app/api/anthropic.py,sha256=UpIP3CgAOUimdVyif41MhBOCAgOyFO8mX9SFQMKRAmc,12483
-app/api/base.py,sha256=bqBT4jne_W6Cvj_GoWWclV4Uk95fQvt-kkYqqZFJd8M,5769
+app/api/base.py,sha256=eShCiZIcW3yeZLONt1xnkP0vU6v5MEaDj3YZ3xcPle8,7294
 app/api/ollama.py,sha256=EBEEKXbgAYWEg_zF5PO_UKO5l_aoU3J_7tfCj9e-fqs,61699
 app/api/openai.py,sha256=6ORruzuuZtIjME3WK-g7kXf7cBmM4td5Njv9JLaWh7E,9557
 app/ui/__init__.py,sha256=RndfbQ1Tv47qdSiuQzvWP96lPS547SDaGE-BgOtiP_w,55
-app/ui/chat_interface.py,sha256=TJlMzVmrKzr3t0JIhto0vKBvyik7gJ7UEyW3Vqbn3cE,17262
+app/ui/chat_interface.py,sha256=0TNtzl_11cAVfh_V8OO-nRbQh0615rOc1N7ri39xxkQ,18428
 app/ui/chat_list.py,sha256=WQTYVNSSXlx_gQal3YqILZZKL9UiTjmNMIDX2I9pAMM,11205
 app/ui/model_browser.py,sha256=pdblLVkdyVF0_Bo02bqbErGAtieyH-y6IfhMOPEqIso,71124
 app/ui/model_selector.py,sha256=ue3rbZfjVsjli-rJN5mfSqq23Ci7NshmTb4xWS-uG5k,18685
 app/ui/search.py,sha256=b-m14kG3ovqW1-i0qDQ8KnAqFJbi5b1FLM9dOnbTyIs,9763
 app/ui/styles.py,sha256=04AhPuLrOd2yenfRySFRestPeuTPeMLzhmMB67NdGvw,5615
-chat_console-0.3.6.dist-info/licenses/LICENSE,sha256=srHZ3fvcAuZY1LHxE7P6XWju2njRCHyK6h_ftEbzxSE,1057
-chat_console-0.3.6.dist-info/METADATA,sha256=WZawRM5bbluU90n7HsSWqcu4sJhCHZbZJg9eLp7BK_Y,2921
-chat_console-0.3.6.dist-info/WHEEL,sha256=pxyMxgL8-pra_rKaQ4drOZAegBVuX-G_4nRHjjgWbmo,91
-chat_console-0.3.6.dist-info/entry_points.txt,sha256=kkVdEc22U9PAi2AeruoKklfkng_a_aHAP6VRVwrAD7c,67
-chat_console-0.3.6.dist-info/top_level.txt,sha256=io9g7LCbfmTG1SFKgEOGXmCFB9uMP2H5lerm0HiHWQE,4
-chat_console-0.3.6.dist-info/RECORD,,
+chat_console-0.3.8.dist-info/licenses/LICENSE,sha256=srHZ3fvcAuZY1LHxE7P6XWju2njRCHyK6h_ftEbzxSE,1057
+chat_console-0.3.8.dist-info/METADATA,sha256=1JGTapio5cA1J_3I9-ujTOcUiFcl29GRy73konykJvE,2921
+chat_console-0.3.8.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
+chat_console-0.3.8.dist-info/entry_points.txt,sha256=kkVdEc22U9PAi2AeruoKklfkng_a_aHAP6VRVwrAD7c,67
+chat_console-0.3.8.dist-info/top_level.txt,sha256=io9g7LCbfmTG1SFKgEOGXmCFB9uMP2H5lerm0HiHWQE,4
+chat_console-0.3.8.dist-info/RECORD,,

{chat_console-0.3.6.dist-info → chat_console-0.3.8.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (79.0.0)
+Generator: setuptools (79.0.1)
 Root-Is-Purelib: true
 Tag: py3-none-any