chat-console 0.3.9__tar.gz → 0.3.94__tar.gz

{chat_console-0.3.9/chat_console.egg-info → chat_console-0.3.94}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chat-console
-Version: 0.3.9
+Version: 0.3.94
 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.9 → chat_console-0.3.94}/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.9"
+__version__ = "0.3.94"

{chat_console-0.3.9 → chat_console-0.3.94}/app/api/base.py

@@ -61,10 +61,12 @@ class BaseModelClient(ABC):
             logger.info(f"Found model in config with provider: {provider}")
         # For custom models, try to infer provider
         else:
-            # First check for OpenAI models - these should ALWAYS use OpenAI client
-            if any(name in model_name_lower for name in ["gpt", "text-", "davinci"]):
+            # Check for common OpenAI model patterns or prefixes
+            if (model_name_lower.startswith(("gpt-", "text-", "davinci")) or 
+                "gpt" in model_name_lower or 
+                model_name_lower in ["04-mini", "04", "04-turbo", "04-vision"]):
                 provider = "openai"
-                logger.info(f"Identified as OpenAI model: {model_name}")
+                logger.info(f"Identified {model_name} as an OpenAI model")
             # 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"
@@ -120,12 +122,14 @@ class BaseModelClient(ABC):
                 raise Exception(f"Provider '{provider}' is not available. Please check your configuration.")
         # For custom models, try to infer provider
         else:
-            # First check for OpenAI models - these should ALWAYS use OpenAI client
-            if any(name in model_name_lower for name in ["gpt", "text-", "davinci"]):
+            # Check for common OpenAI model patterns or prefixes
+            if (model_name_lower.startswith(("gpt-", "text-", "davinci")) or 
+                "gpt" in model_name_lower or 
+                model_name_lower in ["04-mini", "04", "04-turbo", "04-vision"]):
                 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}")
+                logger.info(f"Identified {model_name} as an OpenAI model")
             # 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"]:

{chat_console-0.3.9 → chat_console-0.3.94}/app/api/ollama.py

@@ -11,6 +11,14 @@ from .base import BaseModelClient
 # Set up logging
 logger = logging.getLogger(__name__)
 
+# Custom exception for Ollama API errors
+class OllamaApiError(Exception):
+    """Exception raised for errors in the Ollama API."""
+    def __init__(self, message: str, status_code: Optional[int] = None):
+        self.message = message
+        self.status_code = status_code
+        super().__init__(self.message)
+
 class OllamaClient(BaseModelClient):
     def __init__(self):
         from ..config import OLLAMA_BASE_URL
@@ -280,12 +288,12 @@ class OllamaClient(BaseModelClient):
                     break
                     
             if not model_exists:
-                debug_log(f"Model '{model}' not found in available models")
-                # Instead of failing, yield a helpful error message
-                yield f"Model '{model}' not found. Available models include: {', '.join(available_model_names[:5])}"
+                error_msg = f"Model '{model}' not found in available models. Available models include: {', '.join(available_model_names[:5])}"
                 if len(available_model_names) > 5:
-                    yield f" and {len(available_model_names) - 5} more."
-                yield "\n\nPlease try a different model or check your spelling."
+                    error_msg += f" and {len(available_model_names) - 5} more."
+                logger.error(error_msg)
+                # Instead of raising a custom error, yield the message and return
+                yield error_msg
                 return
         except Exception as e:
             debug_log(f"Error checking model availability: {str(e)}")
@@ -329,10 +337,11 @@ class OllamaClient(BaseModelClient):
                                 if response.status == 404:
                                     error_text = await response.text()
                                     debug_log(f"404 error details: {error_text}")
-                                    # This is likely a model not found error
-                                    yield f"Error: Model '{model}' not found on the Ollama server."
-                                    yield "\nPlease check if the model name is correct or try pulling it first."
-                                    return
+                                    error_msg = f"Error: Model '{model}' not found on the Ollama server. Please check if the model name is correct or try pulling it first."
+                                    logger.error(error_msg)
+                                    # Instead of raising, yield the error message for user display
+                                    yield error_msg
+                                    return  # End the generation
                                     
                                 raise aiohttp.ClientError("Model not ready")
                     except (aiohttp.ClientError, asyncio.TimeoutError) as e:
@@ -363,12 +372,14 @@ class OllamaClient(BaseModelClient):
                                 self._model_loading = False  # Reset flag on failure
                                 
                                 # Check if this is a 404 Not Found error
-                                if pull_response.status == 404:
-                                    error_text = await pull_response.text()
+                                if response.status == 404:
+                                    error_text = await response.text()
                                     debug_log(f"404 error details: {error_text}")
                                     # This is likely a model not found in registry
-                                    yield f"Error: Model '{model}' not found in the Ollama registry."
-                                    yield "\nPlease check if the model name is correct or try a different model."
+                                    error_msg = f"Error: Model '{model}' not found in the Ollama registry. Please check if the model name is correct or try a different model."
+                                    logger.error(error_msg)
+                                    # Instead of raising a custom error, yield the message and return
+                                    yield error_msg
                                     return
                                     
                                 raise Exception("Failed to pull model")
@@ -432,17 +443,34 @@ class OllamaClient(BaseModelClient):
                                 if chunk_str.startswith('{') and chunk_str.endswith('}'):
                                     try:
                                         data = json.loads(chunk_str)
-                                        if isinstance(data, dict) and "response" in data:
-                                            response_text = data["response"]
-                                            if response_text:  # Only yield non-empty responses
-                                                has_yielded_content = True
-                                                chunk_length = len(response_text)
-                                                # Only log occasionally to reduce console spam
-                                                if chunk_length % 20 == 0:
-                                                    debug_log(f"Yielding chunk of length: {chunk_length}")
-                                                yield response_text
+                                        if isinstance(data, dict):
+                                            # Check for error in the chunk
+                                            if "error" in data:
+                                                error_msg = data.get("error", "")
+                                                debug_log(f"Ollama API error in chunk: {error_msg}")
+                                                
+                                                # Handle model loading state
+                                                if "loading model" in error_msg.lower():
+                                                    # Yield a user-friendly message and keep trying
+                                                    yield "The model is still loading. Please wait a moment..."
+                                                    # Add delay before continuing
+                                                    await asyncio.sleep(2)
+                                                    continue
+                                            
+                                            # Process normal response
+                                            if "response" in data:
+                                                response_text = data["response"]
+                                                if response_text:  # Only yield non-empty responses
+                                                    has_yielded_content = True
+                                                    chunk_length = len(response_text)
+                                                    # Only log occasionally to reduce console spam
+                                                    if chunk_length % 20 == 0:
+                                                        debug_log(f"Yielding chunk of length: {chunk_length}")
+                                                    yield response_text
+                                            else:
+                                                debug_log(f"JSON chunk missing 'response' key: {chunk_str[:100]}")
                                         else:
-                                            debug_log(f"JSON chunk missing 'response' key: {chunk_str[:100]}")
+                                            debug_log(f"JSON chunk is not a dict: {chunk_str[:100]}")
                                     except json.JSONDecodeError:
                                         debug_log(f"JSON decode error for chunk: {chunk_str[:100]}")
                                 else:

{chat_console-0.3.9 → chat_console-0.3.94}/app/config.py

@@ -175,35 +175,38 @@ CONFIG = load_config()
 
 # --- Dynamically update Anthropic models after initial load ---
 def update_anthropic_models(config):
-    """Fetch models from Anthropic API and update the config dict."""
+    """Update the config with Anthropic models."""
     if AVAILABLE_PROVIDERS["anthropic"]:
         try:
-            from app.api.anthropic import AnthropicClient # Import here to avoid circular dependency at top level
-            client = AnthropicClient()
-            fetched_models = client.get_available_models() # This now fetches (or uses fallback)
-
-            if fetched_models:
-                # Remove old hardcoded anthropic models first
-                models_to_remove = [
-                    model_id for model_id, info in config["available_models"].items()
-                    if info.get("provider") == "anthropic"
-                ]
-                for model_id in models_to_remove:
-                    del config["available_models"][model_id]
-
-                # Add fetched models
-                for model in fetched_models:
-                    config["available_models"][model["id"]] = {
-                        "provider": "anthropic",
-                        "max_tokens": 4096, # Assign a default max_tokens
-                        "display_name": model["name"]
-                    }
-                print(f"Updated Anthropic models in config: {[m['id'] for m in fetched_models]}") # Add print statement
-            else:
-                 print("Could not fetch or find Anthropic models to update config.") # Add print statement
-
+            # Instead of calling an async method, use a hardcoded fallback list
+            # that matches what's in the AnthropicClient class
+            fallback_models = [
+                {"id": "claude-3-opus-20240229", "name": "Claude 3 Opus"},
+                {"id": "claude-3-sonnet-20240229", "name": "Claude 3 Sonnet"},
+                {"id": "claude-3-haiku-20240307", "name": "Claude 3 Haiku"},
+                {"id": "claude-3-5-sonnet-20240620", "name": "Claude 3.5 Sonnet"},
+                {"id": "claude-3-7-sonnet-20250219", "name": "Claude 3.7 Sonnet"},
+            ]
+            
+            # Remove old models first
+            models_to_remove = [
+                model_id for model_id, info in config["available_models"].items()
+                if info.get("provider") == "anthropic"
+            ]
+            for model_id in models_to_remove:
+                del config["available_models"][model_id]
+                
+            # Add the fallback models
+            for model in fallback_models:
+                config["available_models"][model["id"]] = {
+                    "provider": "anthropic",
+                    "max_tokens": 4096,
+                    "display_name": model["name"]
+                }
+            print(f"Updated Anthropic models in config with fallback list")
+            
         except Exception as e:
-            print(f"Error updating Anthropic models in config: {e}") # Add print statement
+            print(f"Error updating Anthropic models in config: {e}")
             # Keep existing config if update fails
 
     return config

{chat_console-0.3.9 → chat_console-0.3.94}/app/main.py

@@ -20,10 +20,10 @@ file_handler = logging.FileHandler(debug_log_file)
 file_handler.setFormatter(logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s'))
 
 # Get the logger and add the handler
-debug_logger = logging.getLogger("chat-cli-debug")
+debug_logger = logging.getLogger()  # Root logger
 debug_logger.setLevel(logging.DEBUG)
 debug_logger.addHandler(file_handler)
-# Prevent propagation to the root logger (which would print to console)
+# CRITICAL: Force all output to the file, not stdout
 debug_logger.propagate = False
 
 # Add a convenience function to log to this file
@@ -766,7 +766,7 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
         input_widget.focus()
 
     async def generate_response(self) -> None:
-        """Generate an AI response using a non-blocking worker."""
+        """Generate an AI response using a non-blocking worker with fallback."""
         # Import debug_log function from main
         debug_log(f"Entering generate_response method")
         
@@ -774,6 +774,10 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
             debug_log("No current conversation or messages, returning")
             return
 
+        # Track if we've already attempted a fallback to avoid infinite loops
+        if not hasattr(self, 'fallback_attempted'):
+            self.fallback_attempted = False
+
         self.is_generating = True
         log("Setting is_generating to True")
         debug_log("Setting is_generating to True")
@@ -1010,11 +1014,15 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
                 self._loading_animation_task.cancel()
             self._loading_animation_task = None
             try:
+                # Explicitly hide loading indicator
                 loading = self.query_one("#loading-indicator")
                 loading.add_class("hidden")
+                loading.remove_class("model-loading")  # Also remove model-loading class if present
+                self.refresh(layout=True)  # Force a refresh to ensure UI updates
                 self.query_one("#message-input").focus()
-            except Exception:
-                pass # Ignore UI errors during cleanup
+            except Exception as ui_err:
+                debug_log(f"Error hiding loading indicator: {str(ui_err)}")
+                log.error(f"Error hiding loading indicator: {str(ui_err)}")
 
     # Rename this method slightly to avoid potential conflicts and clarify purpose
     async def _handle_generation_result(self, worker: Worker[Optional[str]]) -> None:
@@ -1043,17 +1051,76 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
                 debug_log(f"Error in generation worker: {error}")
                 log.error(f"Error in generation worker: {error}")
                 
-                # Sanitize error message for UI display
+                # Check if this is a model not found error that we can try to recover from
                 error_str = str(error)
+                is_model_not_found = "not found" in error_str.lower() or "404" in error_str
+                
+                # Try fallback if this is a model not found error and we haven't tried fallback yet
+                if is_model_not_found and not self.fallback_attempted:
+                    debug_log("Model not found error detected, attempting fallback")
+                    self.fallback_attempted = True
+                    
+                    # Choose an appropriate fallback based on available providers
+                    fallback_model = None
+                    from app.config import OPENAI_API_KEY, ANTHROPIC_API_KEY
+                    
+                    if OPENAI_API_KEY:
+                        fallback_model = "gpt-3.5-turbo"
+                        debug_log(f"Falling back to OpenAI model: {fallback_model}")
+                    elif ANTHROPIC_API_KEY:
+                        fallback_model = "claude-3-haiku-20240307"
+                        debug_log(f"Falling back to Anthropic model: {fallback_model}")
+                    else:
+                        # Find a common Ollama model that should exist
+                        try:
+                            from app.api.ollama import OllamaClient
+                            ollama = await OllamaClient.create()
+                            models = await ollama.get_available_models()
+                            for model_name in ["gemma:2b", "phi3:mini", "llama3:8b"]:
+                                if any(m["id"] == model_name for m in models):
+                                    fallback_model = model_name
+                                    debug_log(f"Found available Ollama model for fallback: {fallback_model}")
+                                    break
+                        except Exception as e:
+                            debug_log(f"Error finding Ollama fallback model: {str(e)}")
+                    
+                    if fallback_model:
+                        # Update UI to show fallback is happening
+                        loading = self.query_one("#loading-indicator")
+                        loading.remove_class("hidden")
+                        loading.update(f"⚙️ Falling back to {fallback_model}...")
+                        
+                        # Update the selected model
+                        self.selected_model = fallback_model
+                        self.update_app_info()  # Update the displayed model info
+                        
+                        # Remove the "Thinking..." message
+                        if self.messages and self.messages[-1].role == "assistant":
+                            debug_log("Removing thinking message before fallback")
+                            self.messages.pop()
+                            await self.update_messages_ui()
+                        
+                        # Try again with the new model
+                        debug_log(f"Retrying with fallback model: {fallback_model}")
+                        self.notify(f"Trying fallback model: {fallback_model}", severity="warning", timeout=3)
+                        await self.generate_response()
+                        return
                 
-                # Check if this is an Ollama error
-                is_ollama_error = "ollama" in error_str.lower() or "404" in error_str
+                # If we get here, either it's not a model error or fallback already attempted
+                # Explicitly hide loading indicator
+                try:
+                    loading = self.query_one("#loading-indicator")
+                    loading.add_class("hidden")
+                    loading.remove_class("model-loading")  # Also remove model-loading class if present
+                except Exception as ui_err:
+                    debug_log(f"Error hiding loading indicator: {str(ui_err)}")
+                    log.error(f"Error hiding loading indicator: {str(ui_err)}")
                 
                 # Create a user-friendly error message
-                if is_ollama_error:
-                    # For Ollama errors, provide a more user-friendly message
+                if is_model_not_found:
+                    # For model not found 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}")
+                    debug_log(f"Sanitizing model not found 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:
@@ -1069,6 +1136,9 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
                 debug_log(f"Adding error message: {user_error}")
                 self.messages.append(Message(role="assistant", content=user_error))
                 await self.update_messages_ui()
+                
+                # Force a refresh to ensure UI updates
+                self.refresh(layout=True)
 
             elif worker.state == "success":
                 full_response = worker.result

{chat_console-0.3.9 → chat_console-0.3.94}/app/ui/chat_interface.py

@@ -121,77 +121,50 @@ 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"""
-        # Use proper logging instead of print statements
         import logging
         logger = logging.getLogger(__name__)
         logger.debug(f"MessageDisplay.update_content called with content length: {len(content)}")
         
-        # Quick unchanged content check to avoid unnecessary updates
-        if self.message.content == content:
-            logger.debug("Content unchanged, skipping update")
-            return
-            
-        # Special handling for "Thinking..." to ensure it gets replaced
-        if self.message.content == "Thinking..." and content:
-            logger.debug("Replacing 'Thinking...' with actual content")
-            # Force a complete replacement rather than an append
-            self.message.content = ""
-            
-            # Update the stored message object content
+        # Use a lock to prevent race conditions during updates
+        if not hasattr(self, '_update_lock'):
+            self._update_lock = asyncio.Lock()
+        
+        async with self._update_lock:
+            # Special handling for "Thinking..." to ensure it gets replaced
+            if self.message.content == "Thinking..." and content:
+                logger.debug("Replacing 'Thinking...' with actual content")
+                # Force a complete replacement
+                self.message.content = content
+                formatted_content = self._format_content(content)
+                self.update(formatted_content, refresh=True)
+                
+                # Force app-level refresh
+                try:
+                    if self.app:
+                        self.app.refresh(layout=True)
+                        # Find container and scroll
+                        messages_container = self.app.query_one("#messages-container")
+                        if messages_container:
+                            messages_container.scroll_end(animate=False)
+                except Exception as e:
+                    logger.error(f"Error refreshing app: {str(e)}")
+                return
+                
+            # For all other updates - ALWAYS update
             self.message.content = content
-            
-            # Format with fixed-width placeholder to minimize layout shifts
             formatted_content = self._format_content(content)
-            
-            # Use a direct update that forces refresh - critical fix for streaming
             self.update(formatted_content, refresh=True)
             
-            # Force app-level refresh and scroll to ensure visibility
+            # Force refresh
             try:
                 if self.app:
-                    # Force a full layout refresh to ensure content is visible
                     self.app.refresh(layout=True)
-                    
-                    # Find the messages container and scroll to end
-                    containers = self.app.query("ScrollableContainer")
-                    for container in containers:
-                        if hasattr(container, 'scroll_end'):
-                            container.scroll_end(animate=False)
+                    # Find container and scroll
+                    messages_container = self.app.query_one("#messages-container")
+                    if messages_container:
+                        messages_container.scroll_end(animate=False)
             except Exception as e:
                 logger.error(f"Error refreshing app: {str(e)}")
-                self.refresh(layout=True)
-            
-            # Return early to avoid duplicate updates
-            return
-            
-        # Update the stored message object content
-        self.message.content = content
-        
-        # Format with fixed-width placeholder to minimize layout shifts
-        # This avoids text reflowing as new tokens arrive
-        formatted_content = self._format_content(content)
-        
-        # Use a direct update that forces refresh - critical fix for streaming
-        # This ensures content is immediately visible
-        logger.debug(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
-        try:
-            # Always force app refresh for every update
-            if self.app:
-                # Force a full layout refresh to ensure content is visible
-                self.app.refresh(layout=True)
-                
-                # Find the messages container and scroll to end
-                containers = self.app.query("ScrollableContainer")
-                for container in containers:
-                    if hasattr(container, 'scroll_end'):
-                        container.scroll_end(animate=False)
-        except Exception as e:
-            # Log the error and fallback to local refresh
-            logger.error(f"Error refreshing app: {str(e)}")
-            self.refresh(layout=True)
         
     def _format_content(self, content: str) -> str:
         """Format message content with timestamp and handle markdown links"""

{chat_console-0.3.9 → chat_console-0.3.94}/app/ui/model_selector.py

@@ -247,6 +247,11 @@ class ModelSelector(Container):
         """Handle select changes"""
         if event.select.id == "provider-select":
             self.selected_provider = event.value
+            
+            # IMPORTANT: Clear any cached client
+            if hasattr(self.app, 'cached_client'):
+                self.app.cached_client = None
+                
             # Update model options
             model_select = self.query_one("#model-select", Select)
             model_options = await self._get_model_options(self.selected_provider)