chat-console 0.3.91__py3-none-any.whl → 0.3.95__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.91"
+__version__ = "0.3.95"

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"]:

app/api/ollama.py

@@ -292,7 +292,9 @@ class OllamaClient(BaseModelClient):
                 if len(available_model_names) > 5:
                     error_msg += f" and {len(available_model_names) - 5} more."
                 logger.error(error_msg)
-                raise OllamaApiError(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)}")
             # Continue anyway, the main request will handle errors
@@ -370,13 +372,15 @@ 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
                                     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)
-                                    raise OllamaApiError(error_msg, status_code=404)
+                                    # Instead of raising a custom error, yield the message and return
+                                    yield error_msg
+                                    return
                                     
                                 raise Exception("Failed to pull model")
                             logger.info("Model pulled successfully")
@@ -439,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:

app/main.py

@@ -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")
@@ -1047,6 +1051,62 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
                 debug_log(f"Error in generation worker: {error}")
                 log.error(f"Error in generation worker: {error}")
                 
+                # 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
+                
+                # 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")
@@ -1056,17 +1116,11 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
                     debug_log(f"Error hiding loading indicator: {str(ui_err)}")
                     log.error(f"Error hiding loading indicator: {str(ui_err)}")
                 
-                # 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
+                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:

app/ui/chat_interface.py

@@ -120,7 +120,7 @@ class MessageDisplay(Static): # Inherit from Static instead of RichLog
         self.update(self._format_content(self.message.content))
         
     async def update_content(self, content: str) -> None:
-        """Update the message content."""
+        """Update the message content using Static.update() with optimizations for streaming"""
         import logging
         logger = logging.getLogger(__name__)
         logger.debug(f"MessageDisplay.update_content called with content length: {len(content)}")
@@ -130,51 +130,42 @@ class MessageDisplay(Static): # Inherit from Static instead of RichLog
             self._update_lock = asyncio.Lock()
         
         async with self._update_lock:
-            # For initial update from "Thinking..."
+            # Special handling for "Thinking..." to ensure it gets replaced
             if self.message.content == "Thinking..." and content:
-                logger.debug("Replacing 'Thinking...' with initial content")
-                self.message.content = content  # Update the stored content
-                formatted = self._format_content(content)
-                self.update(formatted, refresh=True)
+                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)
                 
-                # Force a clean layout update
+                # Force app-level refresh
                 try:
                     if self.app:
                         self.app.refresh(layout=True)
-                        await asyncio.sleep(0.05)  # Small delay for layout to update
-                        
                         # 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 in initial UI update: {str(e)}")
-                return
-                
-            # Quick unchanged content check to avoid unnecessary updates
-            if self.message.content == content:
-                logger.debug("Content unchanged, skipping update")
+                    logger.error(f"Error refreshing app: {str(e)}")
                 return
                 
-            # For subsequent updates
-            if self.message.content != content:
-                self.message.content = content
-                formatted = self._format_content(content)
-                self.update(formatted, refresh=True)
-                
-                # Use a more targeted refresh approach
-                try:
-                    if self.app:
-                        self.app.refresh(layout=False)  # Lightweight refresh first
-                        # Find container and scroll
-                        messages_container = self.app.query_one("#messages-container")
-                        if messages_container:
-                            messages_container.scroll_end(animate=False)
-                            
-                        # Final full refresh only at end
-                        self.app.refresh(layout=True)
-                except Exception as e:
-                    logger.error(f"Error refreshing UI: {str(e)}")
+            # For all other updates - ALWAYS update
+            self.message.content = content
+            formatted_content = self._format_content(content)
+            # Ensure the update call doesn't have refresh=True
+            self.update(formatted_content) 
+            
+            # Force refresh using app.refresh() instead of passing to update()
+            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)}")
         
     def _format_content(self, content: str) -> str:
         """Format message content with timestamp and handle markdown links"""

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)

app/utils.py

@@ -27,179 +27,64 @@ async def generate_conversation_title(message: str, model: str, client: Any) ->
     
     debug_log(f"Starting title generation with model: {model}, client type: {type(client).__name__}")
     
-    # --- Choose a specific, reliable model for title generation ---
-    # 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
+    # For safety, always use a default title first
+    default_title = f"Conversation ({datetime.now().strftime('%Y-%m-%d %H:%M')})"
     
-    # 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 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
+    # Try-except the entire function to ensure we always return a title
+    try:
+        # Pick a reliable title generation model - prefer OpenAI if available
+        from ..config import OPENAI_API_KEY, ANTHROPIC_API_KEY
+        
+        if OPENAI_API_KEY:
+            from ..api.openai import OpenAIClient
+            title_client = await OpenAIClient.create()
+            title_model = "gpt-3.5-turbo"
+            debug_log("Using OpenAI for title generation")
+        elif ANTHROPIC_API_KEY:
+            from ..api.anthropic import AnthropicClient
+            title_client = await AnthropicClient.create() 
+            title_model = "claude-3-haiku-20240307"
+            debug_log("Using Anthropic for title generation")
         else:
-            # Last resort - use the originally passed model
-            title_model_id = model
+            # Use the passed client if no API keys available
+            title_client = client
+            title_model = model
+            debug_log(f"Using provided {type(client).__name__} for title generation")
         
-        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 = [
-        {
-            "role": "system", 
-            "content": "Generate a brief, descriptive title (maximum 40 characters) for a conversation that starts with the following message. The title should be concise and reflect the main topic or query. Return only the title text with no additional explanation or formatting."
-        },
-        {
-            "role": "user",
-            "content": message
-        }
-    ]
-    
-    tries = 2  # Number of retries
-    last_error = None
-    
-    while tries > 0:
-        try:
-            debug_log(f"Attempt {3-tries} to generate title")
-            # First try generate_completion if available
-            if hasattr(client, 'generate_completion'):
-                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:
-                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()
-            if len(title) > 40:  # Set a maximum title length
-                title = title[:37] + "..."
-                
-            logger.info(f"Generated title: {title}")
-            debug_log(f"Final sanitized title: {title}")
-            return title  # Return successful title
+        # Create a special prompt for title generation
+        title_prompt = [
+            {
+                "role": "system", 
+                "content": "Generate a brief, descriptive title (maximum 40 characters) for a conversation that starts with the following message. Return only the title text with no additional explanation or formatting."
+            },
+            {
+                "role": "user",
+                "content": message
+            }
+        ]
+        
+        # Generate title
+        debug_log(f"Sending title generation request to {title_model}")
+        title = await title_client.generate_completion(
+            messages=title_prompt,
+            model=title_model,
+            temperature=0.7,
+            max_tokens=60
+        )
+        
+        # Sanitize the title
+        title = title.strip().strip('"\'').strip()
+        if len(title) > 40:
+            title = title[:37] + "..."
             
-        except Exception as e:
-            last_error = str(e)
-            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
-                await asyncio.sleep(1)  # Small delay before retry
-    
-    # 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')})"
+        debug_log(f"Generated title: {title}")
+        return title
+        
+    except Exception as e:
+        # Log the error and return default title
+        debug_log(f"Title generation failed: {str(e)}")
+        logger.error(f"Title generation failed: {str(e)}")
+        return default_title
 
 # Helper function for OpenAI streaming
 async def _generate_openai_stream(
@@ -868,7 +753,9 @@ def resolve_model_id(model_id_or_name: str) -> str:
         "04-turbo": "gpt-4-turbo",
         "035": "gpt-3.5-turbo",
         "35-turbo": "gpt-3.5-turbo",
-        "35": "gpt-3.5-turbo"
+        "35": "gpt-3.5-turbo",
+        "4.1-mini": "gpt-4.1-mini",  # Add support for gpt-4.1-mini
+        "4.1": "gpt-4.1"  # Add support for gpt-4.1
     }
     
     if input_lower in openai_model_aliases:

{chat_console-0.3.91.dist-info → chat_console-0.3.95.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chat-console
-Version: 0.3.91
+Version: 0.3.95
 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.91.dist-info → chat_console-0.3.95.dist-info}/RECORD

@@ -1,24 +1,24 @@
-app/__init__.py,sha256=1Z7Qdm9b_jcT0nisliyzs6res69PiL36mZcYaHwpzvY,131
+app/__init__.py,sha256=8Y_-BF1_VRcDOSqGO8CR8u53RZRpt8E6zlGMF6GmQFk,131
 app/config.py,sha256=xeRGXcKbNvAdQGkaJJBipM4yHZJTM1y4ZFoW764APOU,7661
 app/database.py,sha256=nt8CVuDpy6zw8mOYqDcfUmNw611t7Ln7pz22M0b6-MI,9967
-app/main.py,sha256=fYwnYiK4FEpTCBP8QByUBaXyAPWR1h2dG7aLdtcnkzs,75602
+app/main.py,sha256=RmQtbIKtgo92Y5Ue0NbozNP_9BsswLee1rw2la9yEH8,78953
 app/models.py,sha256=4-y9Lytay2exWPFi0FDlVeRL3K2-I7E-jBqNzTfokqY,2644
-app/utils.py,sha256=DsK_Zid9HG9v6cX1y8-4uS_86AgMRTrGFjVn-fctbDM,44949
+app/utils.py,sha256=eGHv4VRjP_qSaYTdLanVffWZXoCh2h3SI0gf2Y6ljes,38824
 app/api/__init__.py,sha256=A8UL84ldYlv8l7O-yKzraVFcfww86SgWfpl4p7R03-w,62
 app/api/anthropic.py,sha256=uInwNvGLJ_iPUs4BjdwaqXTU6NfmK1SzX7498Pt44fI,10667
-app/api/base.py,sha256=Oqu674v0NkrJY91tvxGd6YWgyi6XrFvi03quzWGswg8,7425
-app/api/ollama.py,sha256=zQcrs3COoS4wu9amp5oSmIsBNYK_ntilcGIPOe4wafI,64649
+app/api/base.py,sha256=zvlHHfIcaObefkJ3w4er9ZSX7YGZ_MM0H-wrzD8CGAM,7629
+app/api/ollama.py,sha256=eFG24nI2MlF57z9EHiA97v02NgFJ0kxaPUX26xAXFsg,66154
 app/api/openai.py,sha256=hLPr955tUx_2vwRuLP8Zrl3vu7kQZgUETi4cJuaYnFE,10810
 app/ui/__init__.py,sha256=RndfbQ1Tv47qdSiuQzvWP96lPS547SDaGE-BgOtiP_w,55
-app/ui/chat_interface.py,sha256=prJNmigK7yD-7hb-61mgG2JXcJeDgADySYSElGEUmTg,18683
+app/ui/chat_interface.py,sha256=oSDZi0Jgj_L8WnBh1RuJpIeIcN-RQ38CNejwsXiWTVg,18267
 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/model_selector.py,sha256=9fIPpAiqb568idt9pdROAYaxpoqY9czMF-bGdOl4nYk,18861
 app/ui/search.py,sha256=b-m14kG3ovqW1-i0qDQ8KnAqFJbi5b1FLM9dOnbTyIs,9763
 app/ui/styles.py,sha256=04AhPuLrOd2yenfRySFRestPeuTPeMLzhmMB67NdGvw,5615
-chat_console-0.3.91.dist-info/licenses/LICENSE,sha256=srHZ3fvcAuZY1LHxE7P6XWju2njRCHyK6h_ftEbzxSE,1057
-chat_console-0.3.91.dist-info/METADATA,sha256=7mGtC-c-bML6p0ku5YaFSpYO0rZGbF7NZfhuUUB96u0,2922
-chat_console-0.3.91.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
-chat_console-0.3.91.dist-info/entry_points.txt,sha256=kkVdEc22U9PAi2AeruoKklfkng_a_aHAP6VRVwrAD7c,67
-chat_console-0.3.91.dist-info/top_level.txt,sha256=io9g7LCbfmTG1SFKgEOGXmCFB9uMP2H5lerm0HiHWQE,4
-chat_console-0.3.91.dist-info/RECORD,,
+chat_console-0.3.95.dist-info/licenses/LICENSE,sha256=srHZ3fvcAuZY1LHxE7P6XWju2njRCHyK6h_ftEbzxSE,1057
+chat_console-0.3.95.dist-info/METADATA,sha256=EqxOX-Bugw7Iu2PKQS63pnUYP64UzjkvrNnv2X-Z4fg,2922
+chat_console-0.3.95.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
+chat_console-0.3.95.dist-info/entry_points.txt,sha256=kkVdEc22U9PAi2AeruoKklfkng_a_aHAP6VRVwrAD7c,67
+chat_console-0.3.95.dist-info/top_level.txt,sha256=io9g7LCbfmTG1SFKgEOGXmCFB9uMP2H5lerm0HiHWQE,4
+chat_console-0.3.95.dist-info/RECORD,,