chat-console 0.2.8__py3-none-any.whl → 0.2.98__py3-none-any.whl

app/ui/model_selector.py

@@ -7,6 +7,7 @@ from textual.widget import Widget
 from textual.message import Message
 
 from ..config import CONFIG
+from ..utils import resolve_model_id  # Import the resolve_model_id function
 from ..api.ollama import OllamaClient
 from .chat_interface import ChatInterface
 
@@ -58,7 +59,10 @@ class ModelSelector(Container):
     class ModelSelected(Message):
         """Event sent when a model is selected"""
         def __init__(self, model_id: str):
-            self.model_id = model_id
+            # Always resolve the model ID before sending it to the main app
+            # This ensures short names like "claude-3.7-sonnet" are converted to full IDs
+            self.model_id = resolve_model_id(model_id)
+            logger.info(f"ModelSelected: Original ID '{model_id}' resolved to '{self.model_id}'")
             super().__init__()
     
     def __init__(
@@ -68,7 +72,10 @@ class ModelSelector(Container):
         id: Optional[str] = None
     ):
         super().__init__(name=name, id=id)
-        self.selected_model = selected_model or CONFIG["default_model"]
+        # Resolve the model ID during initialization
+        original_id = selected_model or CONFIG["default_model"]
+        self.selected_model = resolve_model_id(original_id)
+        logger.info(f"ModelSelector.__init__: Original ID '{original_id}' resolved to '{self.selected_model}'")
         # Handle custom models not in CONFIG
         if self.selected_model in CONFIG["available_models"]:
             self.selected_provider = CONFIG["available_models"][self.selected_model]["provider"]
@@ -220,12 +227,48 @@ class ModelSelector(Container):
             model_options = await self._get_model_options(self.selected_provider)
             model_select.set_options(model_options)
             # Select first model of new provider
-            if model_options:
-                self.selected_model = model_options[0][1]
-                model_select.value = self.selected_model
-                model_select.remove_class("hide")
-                self.query_one("#custom-model-input").add_class("hide")
-                self.post_message(self.ModelSelected(self.selected_model))
+            if model_options and len(model_options) > 0:
+                # Check if model_options is properly structured as a list of tuples
+                try:
+                    # Get the first non-custom model if available
+                    first_model = None
+                    for model_option in model_options:
+                        if isinstance(model_option, tuple) and len(model_option) >= 2 and model_option[1] != "custom":
+                            first_model = model_option
+                            break
+                    
+                    # If no non-custom models, use the first model
+                    if not first_model and isinstance(model_options[0], tuple) and len(model_options[0]) >= 2:
+                        first_model = model_options[0]
+                        
+                    # Set the model if we found one
+                    if first_model and len(first_model) >= 2:
+                        # Resolve the model ID before storing and sending
+                        original_id = first_model[1]
+                        resolved_id = resolve_model_id(original_id)
+                        logger.info(f"on_select_changed (provider): Original ID '{original_id}' resolved to '{resolved_id}'")
+                        self.selected_model = resolved_id
+                        model_select.value = resolved_id
+                        model_select.remove_class("hide")
+                        self.query_one("#custom-model-input").add_class("hide")
+                        self.post_message(self.ModelSelected(resolved_id))
+                    else:
+                        # Fall back to custom if no valid model found
+                        self.selected_model = "custom"
+                        model_select.value = "custom"
+                        model_select.add_class("hide")
+                        custom_input = self.query_one("#custom-model-input")
+                        custom_input.remove_class("hide")
+                        custom_input.focus()
+                except (IndexError, TypeError) as e:
+                    logger.error(f"Error selecting first model: {e}")
+                    # Fall back to custom
+                    self.selected_model = "custom"
+                    model_select.value = "custom"
+                    model_select.add_class("hide")
+                    custom_input = self.query_one("#custom-model-input")
+                    custom_input.remove_class("hide")
+                    custom_input.focus()
                 
         elif event.select.id == "model-select":
             if event.value == "custom":
@@ -241,28 +284,43 @@ class ModelSelector(Container):
                 custom_input = self.query_one("#custom-model-input")
                 model_select.remove_class("hide")
                 custom_input.add_class("hide")
-                self.selected_model = event.value
-                self.post_message(self.ModelSelected(event.value))
+                # Resolve the model ID before storing and sending
+                resolved_id = resolve_model_id(event.value)
+                logger.info(f"on_select_changed: Original ID '{event.value}' resolved to '{resolved_id}'")
+                self.selected_model = resolved_id
+                self.post_message(self.ModelSelected(resolved_id))
 
     def on_input_changed(self, event: Input.Changed) -> None:
         """Handle custom model input changes"""
         if event.input.id == "custom-model-input":
             value = event.value.strip()
             if value:  # Only update if there's actual content
-                self.selected_model = value
-                self.post_message(self.ModelSelected(value))
+                # Resolve the model ID before storing and sending
+                resolved_id = resolve_model_id(value)
+                logger.info(f"on_input_changed: Original ID '{value}' resolved to '{resolved_id}'")
+                self.selected_model = resolved_id
+                self.post_message(self.ModelSelected(resolved_id))
             
     def get_selected_model(self) -> str:
-        """Get the current selected model ID"""
-        return self.selected_model
+        """Get the current selected model ID, ensuring it's properly resolved"""
+        resolved_id = resolve_model_id(self.selected_model)
+        logger.info(f"get_selected_model: Original ID '{self.selected_model}' resolved to '{resolved_id}'")
+        return resolved_id
     
     def set_selected_model(self, model_id: str) -> None:
-        """Set the selected model"""
-        self.selected_model = model_id
-        if model_id in CONFIG["available_models"]:
+        """Set the selected model, ensuring it's properly resolved"""
+        # First resolve the model ID to ensure we're using the full ID
+        resolved_id = resolve_model_id(model_id)
+        logger.info(f"set_selected_model: Original ID '{model_id}' resolved to '{resolved_id}'")
+        
+        # Store the resolved ID
+        self.selected_model = resolved_id
+        
+        # Update the UI based on whether this is a known model or custom
+        if resolved_id in CONFIG["available_models"]:
             select = self.query_one("#model-select", Select)
             custom_input = self.query_one("#custom-model-input")
-            select.value = model_id
+            select.value = resolved_id
             select.remove_class("hide")
             custom_input.add_class("hide")
         else:
@@ -270,7 +328,7 @@ class ModelSelector(Container):
             custom_input = self.query_one("#custom-model-input")
             select.value = "custom"
             select.add_class("hide")
-            custom_input.value = model_id
+            custom_input.value = resolved_id
             custom_input.remove_class("hide")
 
 class StyleSelector(Container):

app/utils.py

@@ -4,13 +4,15 @@ import time
 import asyncio
 import subprocess
 import logging
-from typing import Optional, Dict, Any, List, TYPE_CHECKING
+import anthropic # Add missing import
+from typing import Optional, Dict, Any, List, TYPE_CHECKING, Callable, Awaitable
 from datetime import datetime
+from textual import work # Import work decorator
 from .config import CONFIG, save_config
 
 # Import SimpleChatApp for type hinting only if TYPE_CHECKING is True
 if TYPE_CHECKING:
-    from .main import SimpleChatApp
+    from .main import SimpleChatApp # Keep this for type hinting
 
 # Set up logging
 logging.basicConfig(level=logging.INFO)
@@ -18,8 +20,34 @@ 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"""
-    logger.info(f"Generating title for conversation using model: {model}")
-    
+    # --- Choose a specific, reliable model for title generation ---
+    # Prefer Haiku if Anthropic is available, otherwise fallback
+    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
+    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
+
+    logger.info(f"Generating title for conversation using model: {title_model_id}")
+
     # Create a special prompt for title generation
     title_prompt = [
         {
@@ -43,7 +71,7 @@ async def generate_conversation_title(message: str, model: str, client: Any) ->
             if hasattr(client, 'generate_completion'):
                 title = await client.generate_completion(
                     messages=title_prompt,
-                    model=model,
+                    model=title_model_id, # Use the chosen title model
                     temperature=0.7,
                     max_tokens=60  # Titles should be short
                 )
@@ -53,9 +81,18 @@ async def generate_conversation_title(message: str, model: str, client: Any) ->
                  # For now, let's assume a hypothetical non-streaming call or adapt stream
                  # Simplified adaptation: collect stream chunks
                  title_chunks = []
-                 async for chunk in client.generate_stream(title_prompt, model, style=""): # Assuming style might not apply or needs default
-                     title_chunks.append(chunk)
-                 title = "".join(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')})"
             else:
                  raise NotImplementedError("Client does not support a suitable method for title generation.")
 
@@ -78,59 +115,251 @@ async def generate_conversation_title(message: str, model: str, client: Any) ->
     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')})"
 
-# Modified signature to accept app instance
-async def generate_streaming_response(app: 'SimpleChatApp', messages: List[Dict], model: str, style: str, client: Any, callback: Any) -> str:
-    """Generate a streaming response from the model"""
+# Make this the worker function directly
+@work(exit_on_error=True)
+async def generate_streaming_response(
+    app: 'SimpleChatApp',
+    messages: List[Dict],
+    model: str,
+    style: str,
+    client: Any,
+    callback: Callable[[str], Awaitable[None]] # More specific type hint for callback
+) -> Optional[str]: # Return Optional[str] as cancellation might return None implicitly or error
+    """Generate a streaming response from the model (as a Textual worker)"""
+    # Import debug_log function from main
+    # Note: This import might be slightly less reliable inside a worker, but let's try
+    try:
+        from app.main import debug_log
+    except ImportError:
+        debug_log = lambda msg: None # Fallback
+
+    # Worker function needs to handle its own state and cleanup partially
+    # The main app will also need cleanup logic in generate_response
+
     logger.info(f"Starting streaming response with model: {model}")
+    debug_log(f"Starting streaming response with model: '{model}', client type: {type(client).__name__}")
+    
+    # Very defensive check of messages format
+    if not messages:
+        debug_log("Error: messages list is empty")
+        raise ValueError("Messages list cannot be empty")
+    
+    for i, msg in enumerate(messages):
+        try:
+            debug_log(f"Message {i}: role={msg.get('role', 'missing')}, content_len={len(msg.get('content', ''))}")
+            # Ensure essential fields exist
+            if 'role' not in msg:
+                debug_log(f"Adding missing 'role' to message {i}")
+                msg['role'] = 'user'  # Default to user
+            if 'content' not in msg:
+                debug_log(f"Adding missing 'content' to message {i}")
+                msg['content'] = ''  # Default to empty string
+        except Exception as e:
+            debug_log(f"Error checking message {i}: {str(e)}")
+            # Try to repair the message
+            messages[i] = {
+                'role': 'user',
+                'content': str(msg) if msg else ''
+            }
+            debug_log(f"Repaired message {i}")
+    
+    debug_log(f"Messages validation complete: {len(messages)} total messages")
+    
     full_response = ""
     buffer = []
     last_update = time.time()
     update_interval = 0.1  # Update UI every 100ms
-    generation_task = None
     
     try:
-        # The cancellation is now handled by cancelling the asyncio Task in main.py
-        # which will raise CancelledError here, interrupting the loop.
-        async for chunk in client.generate_stream(messages, model, style):
-            if chunk:  # Only process non-empty chunks
-                buffer.append(chunk)
-                current_time = time.time()
+        # Check that we have a valid client and model before proceeding
+        if client is None:
+            debug_log("Error: client is None, cannot proceed with streaming")
+            raise ValueError("Model client is None, cannot proceed with streaming")
+            
+        # Check if the client has the required generate_stream method
+        if not hasattr(client, 'generate_stream'):
+            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")
+            
+        # Set initial model loading state if using Ollama
+        # Always show the model loading indicator for Ollama until we confirm otherwise
+        is_ollama = 'ollama' in str(type(client)).lower()
+        debug_log(f"Is Ollama client: {is_ollama}")
+        
+        if is_ollama and hasattr(app, 'query_one'):
+            try:
+                # Show model loading indicator by default for Ollama
+                debug_log("Showing initial model loading indicator for Ollama")
+                logger.info("Showing initial model loading indicator for Ollama")
+                loading = app.query_one("#loading-indicator")
+                loading.add_class("model-loading")
+                loading.update("⚙️ Loading Ollama model...")
+            except Exception as e:
+                debug_log(f"Error setting initial Ollama loading state: {str(e)}")
+                logger.error(f"Error setting initial Ollama loading state: {str(e)}")
+        
+        # Now proceed with streaming
+        debug_log(f"Starting stream generation with messages length: {len(messages)}")
+        logger.info(f"Starting stream generation for model: {model}")
+        
+        # Defensive approach - wrap the stream generation in a try-except
+        try:
+            debug_log("Calling client.generate_stream()")
+            stream_generator = client.generate_stream(messages, model, style)
+            debug_log("Successfully obtained stream generator")
+        except Exception as stream_init_error:
+            debug_log(f"Error initializing stream generator: {str(stream_init_error)}")
+            logger.error(f"Error initializing stream generator: {str(stream_init_error)}")
+            raise  # Re-raise to be handled in the main catch block
+        
+        # After getting the generator, check if we're NOT in model loading state
+        if 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")
+                loading = app.query_one("#loading-indicator")
+                loading.remove_class("model-loading")
+                loading.update("▪▪▪ Generating response...")
+            except Exception as e:
+                debug_log(f"Error updating UI after stream init: {str(e)}")
+                logger.error(f"Error updating UI after stream init: {str(e)}")
+        
+        # Process the stream with careful error handling
+        debug_log("Beginning to process stream chunks")
+        try:
+            async for chunk in stream_generator:
+                # Check for cancellation frequently
+                if asyncio.current_task().cancelled():
+                    debug_log("Task cancellation detected during chunk processing")
+                    logger.info("Task cancellation detected during chunk processing")
+                    # Close the client stream if possible
+                    if hasattr(client, 'cancel_stream'):
+                        debug_log("Calling client.cancel_stream() due to task cancellation")
+                        await client.cancel_stream()
+                    raise asyncio.CancelledError()
+                    
+                # Check if model loading state changed, but more safely
+                if hasattr(client, 'is_loading_model'):
+                    try:
+                        # Get the model loading state
+                        model_loading = client.is_loading_model()
+                        debug_log(f"Model loading state: {model_loading}")
+                        
+                        # Safely update the UI elements if they exist
+                        if hasattr(app, 'query_one'):
+                            try:
+                                loading = app.query_one("#loading-indicator")
+                                
+                                # Check for class existence first
+                                if model_loading and hasattr(loading, 'has_class') and not loading.has_class("model-loading"):
+                                    # Model loading started
+                                    debug_log("Model loading started during streaming")
+                                    logger.info("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"):
+                                    # Model loading finished
+                                    debug_log("Model loading finished during streaming")
+                                    logger.info("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)}")
                 
-                # Update UI if enough time has passed or buffer is large
-                if current_time - last_update >= update_interval or len(''.join(buffer)) > 100:
-                    new_content = ''.join(buffer)
-                    full_response += new_content
-                    # No need to check app.is_generating here, rely on CancelledError
-                    await callback(full_response)
-                    buffer = []
-                    last_update = current_time
+                # Process the chunk - with careful type handling
+                if chunk:  # Only process non-empty chunks
+                    # Ensure chunk is a string - critical fix for providers returning other types
+                    if not isinstance(chunk, str):
+                        debug_log(f"WARNING: Received non-string chunk of type: {type(chunk).__name__}")
+                        try:
+                            # Try to convert to string if possible
+                            chunk = str(chunk)
+                            debug_log(f"Successfully converted chunk to string, length: {len(chunk)}")
+                        except Exception as e:
+                            debug_log(f"Error converting chunk to string: {str(e)}")
+                            # Skip this chunk since it can't be converted
+                            continue
+                    
+                    debug_log(f"Received chunk of length: {len(chunk)}")
+                    buffer.append(chunk)
+                    current_time = time.time()
                     
-                    # Small delay to let UI catch up
-                    await asyncio.sleep(0.05)
+                    # Update UI if enough time has passed or buffer is large
+                    if current_time - last_update >= update_interval or len(''.join(buffer)) > 100:
+                        new_content = ''.join(buffer)
+                        full_response += new_content
+                        # Send content to UI
+                        debug_log(f"Updating UI with content length: {len(full_response)}")
+                        await callback(full_response)
+                        buffer = []
+                        last_update = current_time
+                        
+                        # Small delay to let UI catch up
+                        await asyncio.sleep(0.05)
+        except asyncio.CancelledError:
+            debug_log("CancelledError in stream processing")
+            raise
+        except Exception as chunk_error:
+            debug_log(f"Error processing stream chunks: {str(chunk_error)}")
+            logger.error(f"Error processing stream chunks: {str(chunk_error)}")
+            raise
 
         # Send any remaining content if the loop finished normally
         if buffer:
             new_content = ''.join(buffer)
             full_response += new_content
+            debug_log(f"Sending final content, total length: {len(full_response)}")
             await callback(full_response)
 
-        logger.info("Streaming response loop finished normally.") # Clarify log message
-        # Add log before returning
-        logger.info(f"generate_streaming_response returning normally. Full response length: {len(full_response)}")
+        debug_log(f"Streaming response completed successfully. Response length: {len(full_response)}")
+        logger.info(f"Streaming response completed successfully. Response length: {len(full_response)}")
         return full_response
+        
     except asyncio.CancelledError:
         # This is expected when the user cancels via Escape
-        logger.info("Streaming response task cancelled.") # Clarify log message
-        # Add log before returning
-        logger.info(f"generate_streaming_response returning after cancellation. Partial response length: {len(full_response)}")
-        # Do not re-raise CancelledError, let the caller handle it
-        return full_response # Return whatever was collected so far (might be partial)
+        debug_log(f"Streaming response task cancelled. Partial response length: {len(full_response)}")
+        logger.info(f"Streaming response task cancelled. Partial response length: {len(full_response)}")
+        # Ensure the client stream is closed
+        if hasattr(client, 'cancel_stream'):
+            debug_log("Calling client.cancel_stream() after cancellation")
+            try:
+                await client.cancel_stream()
+                debug_log("Successfully cancelled client stream")
+            except Exception as cancel_err:
+                debug_log(f"Error cancelling client stream: {str(cancel_err)}")
+        # Return whatever was collected so far
+        return full_response
+        
     except Exception as e:
-        logger.error(f"Error during streaming response: {str(e)}") # Clarify log message
-        # Ensure the app knows generation stopped on error ONLY if it wasn't cancelled
-        if not isinstance(e, asyncio.CancelledError):
-             app.is_generating = False # Reset flag on other errors
-        raise # Re-raise other exceptions
+        debug_log(f"Error during streaming response: {str(e)}")
+        logger.error(f"Error during streaming response: {str(e)}")
+        # Close the client stream if possible
+        if hasattr(client, 'cancel_stream'):
+            debug_log("Attempting to cancel client stream after error")
+            try:
+                await client.cancel_stream()
+                debug_log("Successfully cancelled client stream after error")
+            except Exception as cancel_err:
+                debug_log(f"Error cancelling client stream after error: {str(cancel_err)}")
+        # Re-raise the exception for the worker runner to handle
+        # The @work decorator might catch this depending on exit_on_error
+        raise
+    finally:
+        # Basic cleanup within the worker itself (optional, main cleanup in app)
+        debug_log("generate_streaming_response worker finished or errored.")
+        # Return the full response if successful, otherwise error is raised or cancellation occurred
+        # Note: If cancelled, CancelledError is raised, and @work might handle it.
+        # If successful, return the response.
+        # If error, exception is raised.
+        # Let's explicitly return the response on success.
+        # If cancelled or error, this return might not be reached.
+        if 'full_response' in locals():
+             return full_response
+        return None # Indicate completion without full response (e.g., error before loop)
 
 def ensure_ollama_running() -> bool:
     """
@@ -193,3 +422,107 @@ def save_settings_to_config(model: str, style: str) -> None:
     CONFIG["default_model"] = model
     CONFIG["default_style"] = style
     save_config(CONFIG)
+
+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.
+    """
+    if not model_id_or_name:
+        logger.warning("resolve_model_id called with empty input, returning empty string.")
+        return ""
+
+    input_lower = model_id_or_name.lower().strip()
+    logger.info(f"Attempting to resolve model identifier: '{input_lower}'")
+
+    available_models = CONFIG.get("available_models", {})
+    if not available_models:
+         logger.warning("No available_models found in CONFIG to resolve against.")
+         return model_id_or_name # Return original if no models to check
+
+    # 1. Check if the input is already a valid full ID (must contain a date suffix)
+    # Full Claude IDs should have format like "claude-3-opus-20240229" with a date suffix
+    for full_id in available_models:
+        if full_id.lower() == input_lower:
+            # Only consider it a full ID if it contains a date suffix (like -20240229)
+            if "-202" in full_id:  # Check for date suffix
+                logger.info(f"Input '{model_id_or_name}' is already a full ID with date suffix: '{full_id}'.")
+                return full_id # Return the canonical full_id
+            else:
+                logger.warning(f"Input '{model_id_or_name}' matches a model ID but lacks date suffix.")
+                # Continue searching for a better match with date suffix
+
+    logger.debug(f"Input '{input_lower}' is not a direct full ID match. Checking other criteria...")
+    logger.debug(f"Available models for matching: {list(available_models.keys())}")
+
+    best_match = None
+    match_type = "None"
+
+    # 2. Iterate through available models for other matches
+    for full_id, model_info in available_models.items():
+        full_id_lower = full_id.lower()
+        display_name = model_info.get("display_name", "")
+        display_name_lower = display_name.lower()
+
+        logger.debug(f"Comparing '{input_lower}' against '{full_id_lower}' (Display: '{display_name}')")
+
+        # 2a. Exact match on display name (case-insensitive)
+        if display_name_lower == input_lower:
+            logger.info(f"Resolved '{model_id_or_name}' to '{full_id}' via exact display name match.")
+            return full_id # Exact display name match is high confidence
+
+        # 2b. Check if input is a known short alias (handle common cases explicitly)
+        # Special case for Claude 3.7 Sonnet which seems to be causing issues
+        if input_lower == "claude-3.7-sonnet":
+            # Hardcoded resolution for this specific model
+            claude_37_id = "claude-3-7-sonnet-20250219"
+            logger.warning(f"Special case: Directly mapping '{input_lower}' to '{claude_37_id}'")
+            # Check if this ID exists in available models
+            for model_id in available_models:
+                if model_id.lower() == claude_37_id.lower():
+                    logger.info(f"Found exact match for hardcoded ID: {model_id}")
+                    return model_id
+            # If not found in available models, return the hardcoded ID anyway
+            logger.warning(f"Hardcoded ID '{claude_37_id}' not found in available models, returning it anyway")
+            return claude_37_id
+            
+        # Map common short names to their expected full ID prefixes
+        short_aliases = {
+            "claude-3-opus": "claude-3-opus-",
+            "claude-3-sonnet": "claude-3-sonnet-",
+            "claude-3-haiku": "claude-3-haiku-",
+            "claude-3.5-sonnet": "claude-3-5-sonnet-", # Note the dot vs hyphen
+            "claude-3.7-sonnet": "claude-3-7-sonnet-"  # Added this specific case
+        }
+        if input_lower in short_aliases and full_id_lower.startswith(short_aliases[input_lower]):
+             logger.info(f"Resolved '{model_id_or_name}' to '{full_id}' via known short alias match.")
+             # This is also high confidence
+             return full_id
+
+        # 2c. Check if input is a prefix of the full ID (more general, lower confidence)
+        if full_id_lower.startswith(input_lower):
+            logger.debug(f"Potential prefix match: '{input_lower}' vs '{full_id_lower}'")
+            # Don't return immediately, might find a better match (e.g., display name or alias)
+            if best_match is None: # Only take prefix if no other match found yet
+                 best_match = full_id
+                 match_type = "Prefix"
+                 logger.debug(f"Setting best_match to '{full_id}' based on prefix.")
+
+        # 2d. Check derived short name from display name (less reliable, keep as lower priority)
+        # Normalize display name: lower, replace space and dot with hyphen
+        derived_short_name = display_name_lower.replace(" ", "-").replace(".", "-")
+        if derived_short_name == input_lower:
+             logger.debug(f"Potential derived short name match: '{input_lower}' vs derived '{derived_short_name}' from '{display_name}'")
+             # Prioritize this over a simple prefix match if found
+             if best_match is None or match_type == "Prefix":
+                  best_match = full_id
+                  match_type = "Derived Short Name"
+                  logger.debug(f"Updating best_match to '{full_id}' based on derived name.")
+
+    # 3. Return best match found or original input
+    if best_match:
+        logger.info(f"Returning best match found for '{model_id_or_name}': '{best_match}' (Type: {match_type})")
+        return best_match
+    else:
+        logger.warning(f"Could not resolve model ID or name '{model_id_or_name}' to any known full ID. Returning original.")
+        return model_id_or_name

{chat_console-0.2.8.dist-info → chat_console-0.2.98.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chat-console
-Version: 0.2.8
+Version: 0.2.98
 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