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

app/api/base.py

@@ -61,6 +61,26 @@ class BaseModelClient(ABC):
             logger.info(f"Found model in config with provider: {provider}")
         # For custom models, try to infer provider
         else:
+            # Check if this model was selected from a specific provider in the UI
+            # This would be stored in a temporary attribute on the app instance
+            try:
+                from ..main import SimpleChatApp
+                import inspect
+                frame = inspect.currentframe()
+                while frame:
+                    if 'self' in frame.f_locals and isinstance(frame.f_locals['self'], SimpleChatApp):
+                        app_instance = frame.f_locals['self']
+                        if hasattr(app_instance, 'selected_provider'):
+                            provider = app_instance.selected_provider
+                            logger.info(f"Using provider from UI selection: {provider}")
+                            return OllamaClient if provider == "ollama" else (
+                                   OpenAIClient if provider == "openai" else 
+                                   AnthropicClient if provider == "anthropic" else None)
+                    frame = frame.f_back
+            except Exception as e:
+                logger.error(f"Error checking for UI provider selection: {str(e)}")
+            
+            # If we couldn't get the provider from the UI, infer it from the model name
             # Check for common OpenAI model patterns or prefixes
             if (model_name_lower.startswith(("gpt-", "text-", "davinci")) or 
                 "gpt" in model_name_lower or 
@@ -122,34 +142,57 @@ class BaseModelClient(ABC):
                 raise Exception(f"Provider '{provider}' is not available. Please check your configuration.")
         # For custom models, try to infer provider
         else:
-            # 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 {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"]:
-                    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"]:
+            # Check if this model was selected from a specific provider in the UI
+            provider = None
+            try:
+                from ..main import SimpleChatApp
+                import inspect
+                frame = inspect.currentframe()
+                while frame:
+                    if 'self' in frame.f_locals and isinstance(frame.f_locals['self'], SimpleChatApp):
+                        app_instance = frame.f_locals['self']
+                        if hasattr(app_instance, 'selected_provider'):
+                            provider = app_instance.selected_provider
+                            logger.info(f"Using provider from UI selection: {provider}")
+                            break
+                    frame = frame.f_back
+            except Exception as e:
+                logger.error(f"Error checking for UI provider selection: {str(e)}")
+            
+            # If we couldn't get the provider from the UI, infer it from the model name
+            if not provider:
+                # 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 {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"]:
+                        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"Unknown model type, defaulting to Ollama: {model_name}")
+                    logger.info(f"Identified as Ollama model: {model_name}")
                 else:
-                    raise Exception(f"Unknown model: {model_name}")
+                    # Default to Ollama for unknown models
+                    if AVAILABLE_PROVIDERS["ollama"]:
+                        provider = "ollama"
+                        logger.info(f"Unknown model type, defaulting to Ollama: {model_name}")
+                    else:
+                        raise Exception(f"Unknown model: {model_name}")
+            
+            # Verify the selected provider is available
+            if provider and not AVAILABLE_PROVIDERS.get(provider, False):
+                raise Exception(f"Provider '{provider}' is not available. Please check your configuration.")
         
         # Return appropriate client
         if provider == "ollama":

app/main.py

@@ -643,127 +643,94 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
         # Update UI with user message first
         await self.update_messages_ui()
 
-        # If this is the first message and dynamic titles are enabled, generate one
-        # Only attempt title generation if the message has sufficient content (at least 3 characters)
+        # If this is the first message and dynamic titles are enabled, start background title generation
         if is_first_message and self.current_conversation and CONFIG.get("generate_dynamic_titles", True) and len(content) >= 3:
-            log("First message detected, generating title...")
-            print(f"First message detected, generating conversation title for: {content[:30]}...")
-            debug_log(f"First message detected with length {len(content)}, generating conversation title")
-            
-            # Show loading indicator for title generation
-            loading = self.query_one("#loading-indicator")
-            loading.remove_class("hidden")
-            loading.update("🔤 Generating title...")
+            log("First message detected, starting background title generation...")
+            debug_log(f"First message detected with length {len(content)}, creating background title task")
+            asyncio.create_task(self._generate_title_background(content))
 
-            try:
-                # Get appropriate client
-                model = self.selected_model
-                print(f"Using model for title generation: {model}")
-                debug_log(f"Selected model for title generation: '{model}'")
-                
-                # Check if model is valid
-                if not model:
-                    debug_log("Model is empty, falling back to default")
-                    # Fallback to a safe default model - preferring OpenAI if key exists
-                    if OPENAI_API_KEY:
-                        model = "gpt-3.5-turbo"
-                        debug_log("Falling back to OpenAI gpt-3.5-turbo for title generation")
-                    elif ANTHROPIC_API_KEY:
-                        model = "claude-3-haiku-20240307"  # Updated to newer Claude model
-                        debug_log("Falling back to Anthropic Claude 3 Haiku for title generation")
-                    else:
-                        # Last resort - use a common Ollama model
-                        model = "llama3"  # Common default
-                        debug_log("Falling back to Ollama model: llama3")
+        # Start main response generation immediately
+        debug_log(f"About to call generate_response with model: '{self.selected_model}'")
+        await self.generate_response()
 
-                debug_log(f"Getting client for model: {model}")
-                client = await BaseModelClient.get_client_for_model(model)
-                
-                if client is None:
-                    debug_log(f"No client available for model: {model}, trying to initialize")
-                    # Try to determine client type and initialize manually
-                    client_type = BaseModelClient.get_client_type_for_model(model)
-                    if client_type:
-                        debug_log(f"Found client type {client_type.__name__} for {model}, initializing")
-                        try:
-                            client = await client_type.create()
-                            debug_log("Client initialized successfully")
-                        except Exception as init_err:
-                            debug_log(f"Error initializing client: {str(init_err)}")
-                    
-                    if client is None:
-                        debug_log("Could not initialize client, falling back to safer model")
-                        # Try a different model as last resort
-                        if OPENAI_API_KEY:
-                            from app.api.openai import OpenAIClient
-                            client = await OpenAIClient.create()
-                            model = "gpt-3.5-turbo"
-                            debug_log("Falling back to OpenAI for title generation")
-                        elif ANTHROPIC_API_KEY:
-                            from app.api.anthropic import AnthropicClient
-                            client = await AnthropicClient.create()
-                            model = "claude-3-haiku-20240307"  # Updated to newer Claude model
-                            debug_log("Falling back to Anthropic for title generation")
-                        else:
-                            raise Exception("No valid API clients available for title generation")
+        # Focus back on input
+        input_widget.focus()
 
-                # 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}, 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}")
-                print(f"Generated title: {title}")
+    async def _generate_title_background(self, content: str) -> None:
+        """Generates the conversation title in the background."""
+        if not self.current_conversation or not CONFIG.get("generate_dynamic_titles", True):
+            return
+
+        log("Starting background title generation...")
+        debug_log(f"Background title generation started for content: {content[:30]}...")
 
+        try:
+            # Use the logic from generate_conversation_title in utils.py
+            # It already prioritizes faster models (OpenAI/Anthropic)
+            # We need a client instance here. Let's get one based on priority.
+            title_client = None
+            title_model = None
+            from app.config import OPENAI_API_KEY, ANTHROPIC_API_KEY
+            from app.api.base import BaseModelClient
+
+            # Determine title client and model based on available keys
+            if OPENAI_API_KEY:
+                from app.api.openai import OpenAIClient
+                title_client = await OpenAIClient.create()
+                title_model = "gpt-3.5-turbo"
+                debug_log("Using OpenAI for background title generation")
+            elif ANTHROPIC_API_KEY:
+                from app.api.anthropic import AnthropicClient
+                title_client = await AnthropicClient.create()
+                title_model = "claude-3-haiku-20240307"
+                debug_log("Using Anthropic for background title generation")
+            else:
+                # Fallback to the currently selected model's client if no API keys
+                selected_model_resolved = resolve_model_id(self.selected_model)
+                title_client = await BaseModelClient.get_client_for_model(selected_model_resolved)
+                title_model = selected_model_resolved
+                debug_log(f"Using selected model's client ({type(title_client).__name__}) for background title generation")
+
+            if not title_client or not title_model:
+                raise Exception("Could not determine a client/model for title generation.")
+
+            # Call the utility function
+            from app.utils import generate_conversation_title # Import locally if needed
+            new_title = await generate_conversation_title(content, title_model, title_client)
+            debug_log(f"Background generated title: {new_title}")
+
+            # Check if title generation returned the default or a real title
+            if new_title and not new_title.startswith("Conversation ("):
                 # Update conversation title in database
                 self.db.update_conversation(
                     self.current_conversation.id,
-                    title=title
+                    title=new_title
                 )
 
-                # Update UI title
-                title_widget = self.query_one("#conversation-title", Static)
-                title_widget.update(title)
-
-                # Update conversation object
-                self.current_conversation.title = title
-                
-                # 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)
-
-            except Exception as e:
-                debug_log(f"Failed to generate title: {str(e)}")
-                log.error(f"Failed to generate title: {str(e)}")
-                print(f"Failed to generate title: {str(e)}")
-                self.notify(f"Failed to generate title: {str(e)}", severity="warning")
-            finally:
-                # Hide loading indicator *only if* AI response generation isn't about to start
-                if not self.is_generating:
-                     loading.add_class("hidden")
-                     
-                # Small delay to ensure state is updated
-                await asyncio.sleep(0.1)
-                
-        # Log just before generate_response call
-        debug_log(f"About to call generate_response with model: '{self.selected_model}'")
-                
-        # Generate AI response (will set self.is_generating and handle loading indicator)
-        await self.generate_response()
+                # Update UI title (if conversation hasn't changed)
+                # Check if the current conversation ID still matches
+                # Need to fetch the conversation again to be sure, or check against self.current_conversation.id
+                current_conv_id = self.current_conversation.id if self.current_conversation else None
+                if current_conv_id and self.db.get_conversation(current_conv_id): # Check if conversation still exists
+                    # Check if the app's current conversation is still the same one
+                    if self.current_conversation and self.current_conversation.id == current_conv_id:
+                        title_widget = self.query_one("#conversation-title", Static)
+                        title_widget.update(new_title)
+                        self.current_conversation.title = new_title # Update local object too
+                        log(f"Background title update successful: {new_title}")
+                        # Maybe a subtle notification? Optional.
+                        # self.notify(f"Title set: {new_title}", severity="information", timeout=2)
+                    else:
+                        log("Conversation changed before background title update could apply.")
+                else:
+                    log(f"Conversation with ID {current_conv_id} no longer exists. Skipping title update.")
+            else:
+                log(f"Background title generation resulted in default or empty title: '{new_title}'. Not updating.")
 
-        # Focus back on input
-        input_widget.focus()
+        except Exception as e:
+            debug_log(f"Background title generation failed: {str(e)}")
+            log.error(f"Background title generation failed: {str(e)}")
+            # Do not notify the user, just log the error.
 
     async def generate_response(self) -> None:
         """Generate an AI response using a non-blocking worker with fallback."""
@@ -1248,9 +1215,16 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
             debug_log(f"State change event from unrelated worker: {event.worker.name}")
 
 
-    def on_model_selector_model_selected(self, event: ModelSelector.ModelSelected) -> None: # Keep SimpleChatApp on_model_selector_model_selected
-        """Handle model selection""" # Keep SimpleChatApp on_model_selector_model_selected docstring
-        self.selected_model = event.model_id # Keep SimpleChatApp on_model_selector_model_selected
+    def on_model_selector_model_selected(self, event: ModelSelector.ModelSelected) -> None:
+        """Handle model selection"""
+        self.selected_model = event.model_id
+        
+        # Store the selected provider for use in client resolution
+        model_selector = self.query_one(ModelSelector)
+        if model_selector:
+            self.selected_provider = model_selector.selected_provider
+            log(f"Stored selected provider: {self.selected_provider} for model: {self.selected_model}")
+        
         self.update_app_info()  # Update the displayed model info
 
     def on_style_selector_style_selected(self, event: StyleSelector.StyleSelected) -> None: # Keep SimpleChatApp on_style_selector_style_selected

app/ui/model_selector.py

@@ -251,6 +251,11 @@ class ModelSelector(Container):
             # IMPORTANT: Clear any cached client
             if hasattr(self.app, 'cached_client'):
                 self.app.cached_client = None
+            
+            # Store the selected provider in the app instance for client resolution
+            if hasattr(self.app, 'selected_provider'):
+                self.app.selected_provider = self.selected_provider
+                logger.info(f"Updated app.selected_provider to: {self.selected_provider}")
                 
             # Update model options
             model_select = self.query_one("#model-select", Select)

app/utils.py

@@ -33,15 +33,15 @@ async def generate_conversation_title(message: str, model: str, client: Any) ->
     # 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
+        from app.config import OPENAI_API_KEY, ANTHROPIC_API_KEY
         
         if OPENAI_API_KEY:
-            from ..api.openai import OpenAIClient
+            from app.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
+            from app.api.anthropic import AnthropicClient
             title_client = await AnthropicClient.create() 
             title_model = "claude-3-haiku-20240307"
             debug_log("Using Anthropic for title generation")
@@ -774,6 +774,13 @@ def resolve_model_id(model_id_or_name: str) -> str:
         "o4-vision": "04-vision"
     }
     
+    # Check for more complex typo patterns with dates
+    if input_lower.startswith("o1-") and "-202" in input_lower:
+        corrected = "01" + input_lower[2:]
+        logger.info(f"Converting '{input_lower}' to '{corrected}' (letter 'o' to zero '0')")
+        input_lower = corrected
+        model_id_or_name = corrected
+    
     if input_lower in typo_corrections:
         corrected = typo_corrections[input_lower]
         logger.info(f"Converting '{input_lower}' to '{corrected}' (letter 'o' to zero '0')")

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

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

@@ -1,24 +1,24 @@
-app/__init__.py,sha256=8Y_-BF1_VRcDOSqGO8CR8u53RZRpt8E6zlGMF6GmQFk,131
+app/__init__.py,sha256=QfLH7sifN5qjEB7LzWob9KE-LerEtIww93XlEveeJFo,132
 app/config.py,sha256=xeRGXcKbNvAdQGkaJJBipM4yHZJTM1y4ZFoW764APOU,7661
 app/database.py,sha256=nt8CVuDpy6zw8mOYqDcfUmNw611t7Ln7pz22M0b6-MI,9967
-app/main.py,sha256=RmQtbIKtgo92Y5Ue0NbozNP_9BsswLee1rw2la9yEH8,78953
+app/main.py,sha256=WOcMP6yRwoEzftTSHf0e3zVK1aEuBgKMAsNbzHyKgiA,77427
 app/models.py,sha256=4-y9Lytay2exWPFi0FDlVeRL3K2-I7E-jBqNzTfokqY,2644
-app/utils.py,sha256=eGHv4VRjP_qSaYTdLanVffWZXoCh2h3SI0gf2Y6ljes,38824
+app/utils.py,sha256=AfB6USZdSwkUj75TQzGt_WPAUt1K8wlghON4vRVHUbE,39158
 app/api/__init__.py,sha256=A8UL84ldYlv8l7O-yKzraVFcfww86SgWfpl4p7R03-w,62
 app/api/anthropic.py,sha256=uInwNvGLJ_iPUs4BjdwaqXTU6NfmK1SzX7498Pt44fI,10667
-app/api/base.py,sha256=zvlHHfIcaObefkJ3w4er9ZSX7YGZ_MM0H-wrzD8CGAM,7629
+app/api/base.py,sha256=ELHl7K0jn0OuOfub7lVboigIbym0sv1se_-bCLscPJ8,10232
 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=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=9fIPpAiqb568idt9pdROAYaxpoqY9czMF-bGdOl4nYk,18861
+app/ui/model_selector.py,sha256=2G0TOXfcNodrXZOhLeaJJ2iG3Nck4c_NN1AvUAmaF3M,19172
 app/ui/search.py,sha256=b-m14kG3ovqW1-i0qDQ8KnAqFJbi5b1FLM9dOnbTyIs,9763
 app/ui/styles.py,sha256=04AhPuLrOd2yenfRySFRestPeuTPeMLzhmMB67NdGvw,5615
-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,,
+chat_console-0.3.993.dist-info/licenses/LICENSE,sha256=srHZ3fvcAuZY1LHxE7P6XWju2njRCHyK6h_ftEbzxSE,1057
+chat_console-0.3.993.dist-info/METADATA,sha256=UNHfkJ2M-GN1LnJEMKoI6eqPHIQYlYvwMXLmP4YvY5I,2923
+chat_console-0.3.993.dist-info/WHEEL,sha256=ck4Vq1_RXyvS4Jt6SI0Vz6fyVs4GWg7AINwpsaGEgPE,91
+chat_console-0.3.993.dist-info/entry_points.txt,sha256=kkVdEc22U9PAi2AeruoKklfkng_a_aHAP6VRVwrAD7c,67
+chat_console-0.3.993.dist-info/top_level.txt,sha256=io9g7LCbfmTG1SFKgEOGXmCFB9uMP2H5lerm0HiHWQE,4
+chat_console-0.3.993.dist-info/RECORD,,

{chat_console-0.3.95.dist-info → chat_console-0.3.993.dist-info}/WHEEL

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