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

app/api/anthropic.py

@@ -1,13 +1,17 @@
 import anthropic
-import asyncio  # Add missing import
+import asyncio
+import logging
 from typing import List, Dict, Any, Optional, Generator, AsyncGenerator
 from .base import BaseModelClient
 from ..config import ANTHROPIC_API_KEY
-from ..utils import resolve_model_id  # Import the resolve_model_id function
+
+# Set up logging
+logger = logging.getLogger(__name__)
 
 class AnthropicClient(BaseModelClient):
     def __init__(self):
         self.client = None  # Initialize in create()
+        self._active_stream = None  # Track active stream for cancellation
 
     @classmethod
     async def create(cls) -> 'AnthropicClient':
@@ -17,237 +21,218 @@ class AnthropicClient(BaseModelClient):
         return instance
     
     def _prepare_messages(self, messages: List[Dict[str, str]], style: Optional[str] = None) -> List[Dict[str, str]]:
-        """Prepare messages for Claude API"""
-        # Anthropic expects role to be 'user' or 'assistant'
+        """Prepare messages for Anthropic API"""
         processed_messages = []
         
-        for msg in messages:
-            role = msg["role"]
-            if role == "system":
-                # For Claude, we'll convert system messages to user messages with a special prefix
+        # Add style instructions if provided
+        if style and style != "default":
+            style_instructions = self._get_style_instructions(style)
+            processed_messages.append({
+                "role": "system",
+                "content": style_instructions
+            })
+        
+        # Add the rest of the messages
+        for message in messages:
+            # Ensure message has required fields
+            if "role" not in message or "content" not in message:
+                continue
+                
+            # Map 'user' and 'assistant' roles directly
+            # Anthropic only supports 'user' and 'assistant' roles
+            if message["role"] in ["user", "assistant"]:
+                processed_messages.append(message)
+            elif message["role"] == "system":
+                # For system messages, we need to add them as system messages
                 processed_messages.append({
-                    "role": "user",
-                    "content": f"<system>\n{msg['content']}\n</system>"
+                    "role": "system",
+                    "content": message["content"]
                 })
             else:
-                processed_messages.append(msg)
-        
-        # Add style instructions if provided
-        if style and style != "default":
-            # Find first non-system message to attach style to
-            for i, msg in enumerate(processed_messages):
-                if msg["role"] == "user":
-                    content = msg["content"]
-                    if "<userStyle>" not in content:
-                        style_instructions = self._get_style_instructions(style)
-                        msg["content"] = f"<userStyle>{style_instructions}</userStyle>\n\n{content}"
-                    break
+                # For any other role, treat as user message
+                processed_messages.append({
+                    "role": "user",
+                    "content": message["content"]
+                })
         
         return processed_messages
     
     def _get_style_instructions(self, style: str) -> str:
         """Get formatting instructions for different styles"""
         styles = {
-            "concise": "Be extremely concise and to the point. Use short sentences and paragraphs. Avoid unnecessary details.",
-            "detailed": "Be comprehensive and thorough in your responses. Provide detailed explanations, examples, and cover all relevant aspects of the topic.",
-            "technical": "Use precise technical language and terminology. Be formal and focus on accuracy and technical details.",
-            "friendly": "Be warm, approachable and conversational. Use casual language, personal examples, and a friendly tone.",
+            "concise": "Please provide concise, to-the-point responses without unnecessary elaboration.",
+            "detailed": "Please provide comprehensive responses with thorough explanations and examples.",
+            "technical": "Please use precise technical language and focus on accuracy and technical details.",
+            "friendly": "Please use a warm, conversational tone and relatable examples.",
         }
         
         return styles.get(style, "")
     
-    async def generate_completion(self, messages: List[Dict[str, str]],
-                           model: str,
-                           style: Optional[str] = None,
-                           temperature: float = 0.7,
+    async def generate_completion(self, messages: List[Dict[str, str]], 
+                           model: str, 
+                           style: Optional[str] = None, 
+                           temperature: float = 0.7, 
                            max_tokens: Optional[int] = None) -> str:
-        """Generate a text completion using Claude"""
-        try:
-            from app.main import debug_log
-        except ImportError:
-            debug_log = lambda msg: None
-            
-        # Resolve the model ID right before making the API call
-        original_model = model
-        resolved_model = resolve_model_id(model)
-        debug_log(f"Anthropic: Original model ID '{original_model}' resolved to '{resolved_model}' in generate_completion")
-        
+        """Generate a text completion using Anthropic"""
         processed_messages = self._prepare_messages(messages, style)
         
-        response = await self.client.messages.create(
-            model=resolved_model,  # Use the resolved model ID
-            messages=processed_messages,
-            temperature=temperature,
-            max_tokens=max_tokens or 1024,
-        )
-        
-        return response.content[0].text
+        try:
+            response = await self.client.messages.create(
+                model=model,
+                messages=processed_messages,
+                temperature=temperature,
+                max_tokens=max_tokens if max_tokens else 4096,
+            )
+            
+            return response.content[0].text
+        except Exception as e:
+            logger.error(f"Error generating completion: {str(e)}")
+            raise Exception(f"Anthropic API error: {str(e)}")
     
-    async def generate_stream(self, messages: List[Dict[str, str]],
-                            model: str,
+    async def generate_stream(self, messages: List[Dict[str, str]], 
+                            model: str, 
                             style: Optional[str] = None,
-                            temperature: float = 0.7,
+                            temperature: float = 0.7, 
                             max_tokens: Optional[int] = None) -> AsyncGenerator[str, None]:
-        """Generate a streaming text completion using Claude"""
+        """Generate a streaming text completion using Anthropic"""
         try:
             from app.main import debug_log  # Import debug logging if available
+            debug_log(f"Anthropic: starting streaming generation with model: {model}")
         except ImportError:
             # If debug_log not available, create a no-op function
             debug_log = lambda msg: None
             
-        # Resolve the model ID right before making the API call
-        original_model = model
-        resolved_model = resolve_model_id(model)
-        debug_log(f"Anthropic: Original model ID '{original_model}' resolved to '{resolved_model}'")
-        debug_log(f"Anthropic: starting streaming generation with model: {resolved_model}")
-            
         processed_messages = self._prepare_messages(messages, style)
         
         try:
-            debug_log(f"Anthropic: requesting stream with {len(processed_messages)} messages")
-            # Remove await from this line - it returns the context manager, not an awaitable
-            stream = self.client.messages.stream(
-                model=resolved_model,  # Use the resolved model ID
-                messages=processed_messages,
-                temperature=temperature,
-                max_tokens=max_tokens or 1024,
-            )
+            debug_log(f"Anthropic: preparing {len(processed_messages)} messages for stream")
+            
+            # Use more robust error handling with retry for connection issues
+            max_retries = 2
+            retry_count = 0
             
-            debug_log("Anthropic: stream created successfully, processing chunks using async with")
-            async with stream as stream_context: # Use async with
-                async for chunk in stream_context: # Iterate over the context
-                    try:
-                        if chunk.type == "content_block_delta": # Check for delta type
-                            # Ensure we always return a string
-                            if chunk.delta.text is None:
-                                debug_log("Anthropic: skipping empty text delta chunk")
-                                continue
-                                
-                            text = str(chunk.delta.text) # Get text from delta
-                            debug_log(f"Anthropic: yielding chunk of length: {len(text)}")
-                            yield text
-                        else:
-                            debug_log(f"Anthropic: skipping non-content_delta chunk of type: {chunk.type}")
-                    except Exception as chunk_error: # Restore the except block for chunk processing
-                        debug_log(f"Anthropic: error processing chunk: {str(chunk_error)}")
-                        # Skip problematic chunks but continue processing
-                        continue # This continue is now correctly inside the loop and except block
+            while retry_count <= max_retries:
+                try:
+                    debug_log(f"Anthropic: creating stream with model {model}")
+                    
+                    # Create the stream
+                    stream = await self.client.messages.create(
+                        model=model,
+                        messages=processed_messages,
+                        temperature=temperature,
+                        max_tokens=max_tokens if max_tokens else 4096,
+                        stream=True
+                    )
+                    
+                    # Store the stream for potential cancellation
+                    self._active_stream = stream
                     
+                    debug_log("Anthropic: stream created successfully")
+                    
+                    # Process stream chunks
+                    chunk_count = 0
+                    debug_log("Anthropic: starting to process chunks")
+                    
+                    async for chunk in stream:
+                        # Check if stream has been cancelled
+                        if self._active_stream is None:
+                            debug_log("Anthropic: stream was cancelled, stopping generation")
+                            break
+                            
+                        chunk_count += 1
+                        try:
+                            if hasattr(chunk, 'delta') and hasattr(chunk.delta, 'text'):
+                                content = chunk.delta.text
+                                if content is not None:
+                                    debug_log(f"Anthropic: yielding chunk {chunk_count} of length: {len(content)}")
+                                    yield content
+                                else:
+                                    debug_log(f"Anthropic: skipping None content chunk {chunk_count}")
+                            else:
+                                debug_log(f"Anthropic: skipping chunk {chunk_count} with missing content")
+                        except Exception as chunk_error:
+                            debug_log(f"Anthropic: error processing chunk {chunk_count}: {str(chunk_error)}")
+                            # Skip problematic chunks but continue processing
+                            continue
+                    
+                    debug_log(f"Anthropic: stream completed successfully with {chunk_count} chunks")
+                    
+                    # Clear the active stream reference when done
+                    self._active_stream = None
+                    
+                    # If we reach this point, we've successfully processed the stream
+                    break
+                    
+                except Exception as e:
+                    debug_log(f"Anthropic: error in attempt {retry_count+1}/{max_retries+1}: {str(e)}")
+                    retry_count += 1
+                    if retry_count <= max_retries:
+                        debug_log(f"Anthropic: retrying after error (attempt {retry_count+1})")
+                        # Simple exponential backoff
+                        await asyncio.sleep(1 * retry_count)
+                    else:
+                        debug_log("Anthropic: max retries reached, raising exception")
+                        raise Exception(f"Anthropic streaming error after {max_retries+1} attempts: {str(e)}")
+                        
         except Exception as e:
             debug_log(f"Anthropic: error in generate_stream: {str(e)}")
+            # Yield a simple error message as a last resort to ensure UI updates
+            yield f"Error: {str(e)}"
             raise Exception(f"Anthropic streaming error: {str(e)}")
-
-    async def _fetch_models_from_api(self) -> List[Dict[str, Any]]:
-        """Fetch available models directly from the Anthropic API."""
+    
+    async def cancel_stream(self) -> None:
+        """Cancel any active streaming request"""
+        logger.info("Cancelling active Anthropic stream")
         try:
             from app.main import debug_log
+            debug_log("Anthropic: cancelling active stream")
         except ImportError:
-            debug_log = lambda msg: None
-
-        # Always include a reliable fallback list in case API calls fail
-        fallback_models = [
-            {"id": "claude-3-opus-20240229", "name": "Claude 3 Opus"},
-            {"id": "claude-3-sonnet-20240229", "name": "Claude 3 Sonnet"},
-            {"id": "claude-3-haiku-20240307", "name": "Claude 3 Haiku"},
-            {"id": "claude-3-5-sonnet-20240620", "name": "Claude 3.5 Sonnet"},
-            {"id": "claude-3-7-sonnet-20250219", "name": "Claude 3.7 Sonnet"},
-        ]
-
-        # If no client is initialized, return fallback immediately
-        if not self.client:
-            debug_log("Anthropic: No client initialized, using fallback models")
-            return fallback_models
-
-        try:
-            debug_log("Anthropic: Fetching models from API...")
-            
-            # Try using the models.list method if available in newer SDK versions
-            if hasattr(self.client, 'models') and hasattr(self.client.models, 'list'):
-                try:
-                    debug_log("Anthropic: Using client.models.list() method")
-                    models_response = await self.client.models.list()
-                    if hasattr(models_response, 'data') and isinstance(models_response.data, list):
-                        formatted_models = [
-                            {"id": model.id, "name": getattr(model, "name", model.id)}
-                            for model in models_response.data
-                        ]
-                        debug_log(f"Anthropic: Found {len(formatted_models)} models via SDK")
-                        return formatted_models
-                except Exception as sdk_err:
-                    debug_log(f"Anthropic: Error using models.list(): {str(sdk_err)}")
-                    # Continue to next method
+            pass
             
-            # Try direct HTTP request if client exposes the underlying HTTP client
-            if hasattr(self.client, '_client') and hasattr(self.client._client, 'get'):
-                try:
-                    debug_log("Anthropic: Using direct HTTP request to /v1/models")
-                    response = await self.client._client.get(
-                        "/v1/models",
-                        headers={"anthropic-version": "2023-06-01"}
-                    )
-                    response.raise_for_status()
-                    models_data = response.json()
-                    
-                    if 'data' in models_data and isinstance(models_data['data'], list):
-                        formatted_models = [
-                            {"id": model.get("id"), "name": model.get("display_name", model.get("id"))}
-                            for model in models_data['data']
-                            if model.get("id")
-                        ]
-                        debug_log(f"Anthropic: Found {len(formatted_models)} models via HTTP request")
-                        return formatted_models
-                    else:
-                        debug_log("Anthropic: Unexpected API response format")
-                except Exception as http_err:
-                    debug_log(f"Anthropic: HTTP request error: {str(http_err)}")
-                    # Continue to fallback
-            
-            # If we reach here, both methods failed
-            debug_log("Anthropic: All API methods failed, using fallback models")
-            return fallback_models
-
-        except Exception as e:
-            debug_log(f"Anthropic: Failed to fetch models from API: {str(e)}")
-            debug_log("Anthropic: Using fallback model list")
-            return fallback_models
-
-    def get_available_models(self) -> List[Dict[str, Any]]:
-        """Get list of available Claude models by fetching from API."""
-        # Reliable fallback list that doesn't depend on async operations
-        fallback_models = [
-            {"id": "claude-3-opus-20240229", "name": "Claude 3 Opus"},
-            {"id": "claude-3-sonnet-20240229", "name": "Claude 3 Sonnet"},
-            {"id": "claude-3-haiku-20240307", "name": "Claude 3 Haiku"},
-            {"id": "claude-3-5-sonnet-20240620", "name": "Claude 3.5 Sonnet"},
-            {"id": "claude-3-7-sonnet-20250219", "name": "Claude 3.7 Sonnet"},
+        # Simply set the active stream to None
+        # This will cause the generate_stream method to stop processing chunks
+        self._active_stream = None
+        logger.info("Anthropic stream cancelled successfully")
+    
+    async def get_available_models(self) -> List[Dict[str, Any]]:
+        """Get list of available Anthropic models"""
+        # Anthropic doesn't have a models endpoint, so we return a static list
+        models = [
+            {
+                "id": "claude-3-opus-20240229",
+                "name": "Claude 3 Opus",
+                "description": "Most powerful model for highly complex tasks",
+                "context_window": 200000,
+                "provider": "anthropic"
+            },
+            {
+                "id": "claude-3-sonnet-20240229",
+                "name": "Claude 3 Sonnet",
+                "description": "Balanced model for most tasks",
+                "context_window": 200000,
+                "provider": "anthropic"
+            },
+            {
+                "id": "claude-3-haiku-20240307",
+                "name": "Claude 3 Haiku",
+                "description": "Fastest and most compact model",
+                "context_window": 200000,
+                "provider": "anthropic"
+            },
+            {
+                "id": "claude-3-5-sonnet-20240620",
+                "name": "Claude 3.5 Sonnet",
+                "description": "Latest model with improved capabilities",
+                "context_window": 200000,
+                "provider": "anthropic"
+            },
+            {
+                "id": "claude-3-7-sonnet-20250219",
+                "name": "Claude 3.7 Sonnet",
+                "description": "Newest model with advanced reasoning",
+                "context_window": 200000,
+                "provider": "anthropic"
+            }
         ]
         
-        try:
-            # Check if we're already in an event loop
-            try:
-                loop = asyncio.get_running_loop()
-                in_loop = True
-            except RuntimeError:
-                in_loop = False
-                
-            if in_loop:
-                # We're already in an event loop, create a future
-                try:
-                    from app.main import debug_log
-                except ImportError:
-                    debug_log = lambda msg: None
-                    
-                debug_log("Anthropic: Already in event loop, using fallback models")
-                return fallback_models
-            else:
-                # Not in an event loop, we can use asyncio.run
-                models = asyncio.run(self._fetch_models_from_api())
-                return models
-        except Exception as e:
-            try:
-                from app.main import debug_log
-            except ImportError:
-                debug_log = lambda msg: None
-                
-            debug_log(f"Anthropic: Error in get_available_models: {str(e)}")
-            return fallback_models
+        return models

app/api/base.py

@@ -22,6 +22,11 @@ class BaseModelClient(ABC):
         """Generate a streaming text completion"""
         yield ""  # Placeholder implementation
     
+    @abstractmethod
+    async def cancel_stream(self) -> None:
+        """Cancel any active streaming request"""
+        pass
+    
     @abstractmethod
     def get_available_models(self) -> List[Dict[str, Any]]:
         """Get list of available models from this provider"""

app/api/ollama.py

@@ -266,6 +266,31 @@ class OllamaClient(BaseModelClient):
         last_error = None
         self._active_stream_session = None  # Track the active session
         
+        # First check if the model exists in our available models
+        try:
+            available_models = await self.get_available_models()
+            model_exists = False
+            available_model_names = []
+            
+            for m in available_models:
+                model_id = m.get("id", "")
+                available_model_names.append(model_id)
+                if model_id == model:
+                    model_exists = True
+                    break
+                    
+            if not model_exists:
+                debug_log(f"Model '{model}' not found in available models")
+                # Instead of failing, yield a helpful error message
+                yield f"Model '{model}' not found. Available models include: {', '.join(available_model_names[:5])}"
+                if len(available_model_names) > 5:
+                    yield f" and {len(available_model_names) - 5} more."
+                yield "\n\nPlease try a different model or check your spelling."
+                return
+        except Exception as e:
+            debug_log(f"Error checking model availability: {str(e)}")
+            # Continue anyway, the main request will handle errors
+        
         while retries >= 0:
             try:
                 # First try a quick test request to check if model is loaded
@@ -299,6 +324,16 @@ class OllamaClient(BaseModelClient):
                             if response.status != 200:
                                 logger.warning(f"Model test request failed with status {response.status}")
                                 debug_log(f"Model test request failed with status {response.status}")
+                                
+                                # Check if this is a 404 Not Found error
+                                if response.status == 404:
+                                    error_text = await response.text()
+                                    debug_log(f"404 error details: {error_text}")
+                                    # This is likely a model not found error
+                                    yield f"Error: Model '{model}' not found on the Ollama server."
+                                    yield "\nPlease check if the model name is correct or try pulling it first."
+                                    return
+                                    
                                 raise aiohttp.ClientError("Model not ready")
                     except (aiohttp.ClientError, asyncio.TimeoutError) as e:
                         logger.info(f"Model cold start detected: {str(e)}")
@@ -326,6 +361,16 @@ class OllamaClient(BaseModelClient):
                                 logger.error("Failed to pull model")
                                 debug_log("Failed to pull model")
                                 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()
+                                    debug_log(f"404 error details: {error_text}")
+                                    # This is likely a model not found in registry
+                                    yield f"Error: Model '{model}' not found in the Ollama registry."
+                                    yield "\nPlease check if the model name is correct or try a different model."
+                                    return
+                                    
                                 raise Exception("Failed to pull model")
                             logger.info("Model pulled successfully")
                             debug_log("Model pulled successfully")

app/api/openai.py

@@ -3,10 +3,15 @@ import asyncio
 from typing import List, Dict, Any, Optional, Generator, AsyncGenerator
 from .base import BaseModelClient
 from ..config import OPENAI_API_KEY
+import logging
+
+# Set up logging
+logger = logging.getLogger(__name__)
 
 class OpenAIClient(BaseModelClient):
     def __init__(self):
         self.client = None  # Initialize in create()
+        self._active_stream = None  # Track active stream for cancellation
 
     @classmethod
     async def create(cls) -> 'OpenAIClient':
@@ -115,6 +120,10 @@ class OpenAIClient(BaseModelClient):
                         max_tokens=max_tokens,
                         stream=True,
                     )
+                    
+                    # Store the stream for potential cancellation
+                    self._active_stream = stream
+                    
                     debug_log("OpenAI: stream created successfully")
                     
                     # Yield a small padding token at the beginning for very short prompts
@@ -128,6 +137,11 @@ class OpenAIClient(BaseModelClient):
                     debug_log("OpenAI: starting to process chunks")
                     
                     async for chunk in stream:
+                        # Check if stream has been cancelled
+                        if self._active_stream is None:
+                            debug_log("OpenAI: stream was cancelled, stopping generation")
+                            break
+                            
                         chunk_count += 1
                         try:
                             if chunk.choices and hasattr(chunk.choices[0], 'delta') and hasattr(chunk.choices[0].delta, 'content'):
@@ -148,6 +162,9 @@ class OpenAIClient(BaseModelClient):
                     
                     debug_log(f"OpenAI: stream completed successfully with {chunk_count} chunks")
                     
+                    # Clear the active stream reference when done
+                    self._active_stream = None
+                    
                     # If we reach this point, we've successfully processed the stream
                     break
                     
@@ -168,6 +185,20 @@ class OpenAIClient(BaseModelClient):
             yield f"Error: {str(e)}"
             raise Exception(f"OpenAI streaming error: {str(e)}")
     
+    async def cancel_stream(self) -> None:
+        """Cancel any active streaming request"""
+        logger.info("Cancelling active OpenAI stream")
+        try:
+            from app.main import debug_log
+            debug_log("OpenAI: cancelling active stream")
+        except ImportError:
+            pass
+            
+        # Simply set the active stream to None
+        # This will cause the generate_stream method to stop processing chunks
+        self._active_stream = None
+        logger.info("OpenAI stream cancelled successfully")
+    
     async def get_available_models(self) -> List[Dict[str, Any]]:
         """Fetch list of available OpenAI models from the /models endpoint"""
         try:

app/main.py

@@ -940,27 +940,39 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
             last_refresh_time = time.time()  # Initialize refresh throttling timer
 
             async def update_ui(content: str):
-                # This function remains the same, called by the worker
+                # This function is called by the worker with each content update
                 if not self.is_generating:
                     debug_log("update_ui called but is_generating is False, returning.")
                     return
                 
                 async with update_lock:
                     try:
+                        # Add more verbose logging
+                        debug_log(f"update_ui called with content length: {len(content)}")
+                        print(f"update_ui: Updating with content length {len(content)}")
+                        
                         # Clear thinking indicator on first content
                         if assistant_message.content == "Thinking...":
                             debug_log("First content received, clearing 'Thinking...'")
                             print("First content received, clearing 'Thinking...'")
-                            assistant_message.content = ""
-
+                            # We'll let the MessageDisplay.update_content handle this special case
+                        
                         # Update the message object with the full content
                         assistant_message.content = content
 
-                        # Update UI with the content
+                        # Update UI with the content - this now has special handling for "Thinking..."
+                        debug_log("Calling message_display.update_content")
                         await message_display.update_content(content)
                         
-                        # Simple refresh approach - just force a layout refresh
+                        # More aggressive UI refresh sequence
+                        debug_log("Performing UI refresh sequence")
+                        # First do a lightweight refresh
+                        self.refresh(layout=False)
+                        # Then scroll to end
+                        messages_container.scroll_end(animate=False)
+                        # Then do a full layout refresh
                         self.refresh(layout=True)
+                        # Final scroll to ensure visibility
                         messages_container.scroll_end(animate=False)
                         
                     except Exception as e:
@@ -1030,14 +1042,32 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
                 error = worker.error
                 debug_log(f"Error in generation worker: {error}")
                 log.error(f"Error in generation worker: {error}")
-                self.notify(f"Generation error: {error}", severity="error", timeout=5)
+                
+                # Sanitize error message for UI display
+                error_str = str(error)
+                
+                # Check if this is an Ollama error
+                is_ollama_error = "ollama" in error_str.lower() or "404" in error_str
+                
+                # Create a user-friendly error message
+                if is_ollama_error:
+                    # For Ollama errors, provide a more user-friendly message
+                    user_error = "Unable to generate response. The selected model may not be available."
+                    debug_log(f"Sanitizing Ollama error to user-friendly message: {user_error}")
+                    # Show technical details only in notification, not in chat
+                    self.notify(f"Model error: {error_str}", severity="error", timeout=5)
+                else:
+                    # For other errors, show a generic message
+                    user_error = f"Error generating response: {error_str}"
+                    self.notify(f"Generation error: {error_str}", severity="error", timeout=5)
+                
                 # Add error message to UI
                 if self.messages and self.messages[-1].role == "assistant":
                     debug_log("Removing thinking message")
                     self.messages.pop()  # Remove thinking message
-                error_msg = f"Error: {error}"
-                debug_log(f"Adding error message: {error_msg}")
-                self.messages.append(Message(role="assistant", content=error_msg))
+                
+                debug_log(f"Adding error message: {user_error}")
+                self.messages.append(Message(role="assistant", content=user_error))
                 await self.update_messages_ui()
 
             elif worker.state == "success":

app/ui/chat_interface.py

@@ -121,11 +121,50 @@ class MessageDisplay(Static): # Inherit from Static instead of RichLog
         
     async def update_content(self, content: str) -> None:
         """Update the message content using Static.update() with optimizations for streaming"""
+        # Use proper logging instead of print statements
+        import logging
+        logger = logging.getLogger(__name__)
+        logger.debug(f"MessageDisplay.update_content called with content length: {len(content)}")
+        
         # Quick unchanged content check to avoid unnecessary updates
         if self.message.content == content:
+            logger.debug("Content unchanged, skipping update")
+            return
+            
+        # Special handling for "Thinking..." to ensure it gets replaced
+        if self.message.content == "Thinking..." and content:
+            logger.debug("Replacing 'Thinking...' with actual content")
+            # Force a complete replacement rather than an append
+            self.message.content = ""
+            
+            # Update the stored message object content
+            self.message.content = content
+            
+            # Format with fixed-width placeholder to minimize layout shifts
+            formatted_content = self._format_content(content)
+            
+            # Use a direct update that forces refresh - critical fix for streaming
+            self.update(formatted_content, refresh=True)
+            
+            # Force app-level refresh and scroll to ensure visibility
+            try:
+                if self.app:
+                    # Force a full layout refresh to ensure content is visible
+                    self.app.refresh(layout=True)
+                    
+                    # Find the messages container and scroll to end
+                    containers = self.app.query("ScrollableContainer")
+                    for container in containers:
+                        if hasattr(container, 'scroll_end'):
+                            container.scroll_end(animate=False)
+            except Exception as e:
+                logger.error(f"Error refreshing app: {str(e)}")
+                self.refresh(layout=True)
+            
+            # Return early to avoid duplicate updates
             return
             
-        # Update the stored message object content first
+        # Update the stored message object content
         self.message.content = content
         
         # Format with fixed-width placeholder to minimize layout shifts
@@ -134,6 +173,7 @@ class MessageDisplay(Static): # Inherit from Static instead of RichLog
         
         # Use a direct update that forces refresh - critical fix for streaming
         # This ensures content is immediately visible
+        logger.debug(f"Updating widget with formatted content length: {len(formatted_content)}")
         self.update(formatted_content, refresh=True)
         
         # Force app-level refresh and scroll to ensure visibility
@@ -150,13 +190,18 @@ class MessageDisplay(Static): # Inherit from Static instead of RichLog
                         container.scroll_end(animate=False)
         except Exception as e:
             # Log the error and fallback to local refresh
-            print(f"Error refreshing app: {str(e)}")
+            logger.error(f"Error refreshing app: {str(e)}")
             self.refresh(layout=True)
         
     def _format_content(self, content: str) -> str:
         """Format message content with timestamp and handle markdown links"""
         timestamp = datetime.now().strftime("%H:%M")
         
+        # Special handling for "Thinking..." to make it visually distinct
+        if content == "Thinking...":
+            # Use italic style for the thinking indicator
+            return f"[dim]{timestamp}[/dim] [italic]{content}[/italic]"
+            
         # Fix markdown-style links that cause markup errors
         # Convert [text](url) to a safe format for Textual markup
         content = re.sub(
@@ -170,8 +215,8 @@ class MessageDisplay(Static): # Inherit from Static instead of RichLog
         # But keep our timestamp markup
         timestamp_markup = f"[dim]{timestamp}[/dim]"
         
-        # Debug print to verify content is being formatted
-        print(f"Formatting content: {len(content)} chars")
+        # Use proper logging instead of print
+        logger.debug(f"Formatting content: {len(content)} chars")
         
         return f"{timestamp_markup} {content}"
 

app/utils.py

@@ -63,17 +63,62 @@ async def generate_conversation_title(message: str, model: str, client: Any) ->
 
     # Check if client is OpenAI
     is_openai = 'openai' in str(type(client)).lower()
-    if is_openai and not title_model_id:
+    if is_openai:
         debug_log("Using OpenAI client for title generation")
         # Use GPT-3.5 for title generation (fast and cost-effective)
         title_model_id = "gpt-3.5-turbo"
         debug_log(f"Using OpenAI model for title generation: {title_model_id}")
+        # For OpenAI, we'll always use their model, not fall back to the passed model
+        # This prevents trying to use Ollama models with OpenAI client
+    
+    # Check if client is Ollama
+    is_ollama = 'ollama' in str(type(client)).lower()
+    if is_ollama and not title_model_id:
+        debug_log("Using Ollama client for title generation")
+        # For Ollama, check if the model exists before using it
+        try:
+            # Try a quick test request to check if model exists
+            debug_log(f"Testing if Ollama model exists: {model}")
+            import aiohttp
+            async with aiohttp.ClientSession() as session:
+                try:
+                    base_url = "http://localhost:11434"
+                    async with session.post(
+                        f"{base_url}/api/generate",
+                        json={"model": model, "prompt": "test", "stream": False},
+                        timeout=2
+                    ) as response:
+                        if response.status == 200:
+                            # Model exists, use it
+                            title_model_id = model
+                            debug_log(f"Ollama model {model} exists, using it for title generation")
+                        else:
+                            debug_log(f"Ollama model {model} returned status {response.status}, falling back to default")
+                            # Fall back to a common model
+                            title_model_id = "llama3"
+                except Exception as e:
+                    debug_log(f"Error testing Ollama model: {str(e)}, falling back to default")
+                    # Fall back to a common model
+                    title_model_id = "llama3"
+        except Exception as e:
+            debug_log(f"Error checking Ollama model: {str(e)}")
+            # Fall back to a common model
+            title_model_id = "llama3"
     
     # Fallback logic if no specific model was found
     if not title_model_id:
-        # Use the originally passed model as the final fallback
-        title_model_id = model
-        debug_log(f"Falling back to originally selected model for title generation: {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
+        else:
+            # Last resort - use the originally passed model
+            title_model_id = model
+        
+        debug_log(f"No specific model found, using fallback model for title generation: {title_model_id}")
     
     logger.info(f"Generating title for conversation using model: {title_model_id}")
     debug_log(f"Final model selected for title generation: {title_model_id}")
@@ -325,25 +370,26 @@ async def generate_streaming_response(
                         full_response += new_content
                         debug_log(f"Updating UI with content length: {len(full_response)}")
                         
-                        # Only print to console for debugging if not OpenAI
-                        # This prevents Ollama debug output from appearing in OpenAI responses
-                        if not is_openai:
-                            print(f"Streaming update: +{len(new_content)} chars, total: {len(full_response)}")
+                        # Enhanced debug logging
+                        print(f"STREAM DEBUG: +{len(new_content)} chars, total: {len(full_response)}")
+                        # Print first few characters of content for debugging
+                        if len(full_response) < 100:
+                            print(f"STREAM CONTENT: '{full_response}'")
                         
                         try:
                             # Call the UI callback with the full response so far
+                            debug_log("Calling UI callback with content")
                             await callback(full_response)
                             debug_log("UI callback completed successfully")
                             
                             # Force app refresh after each update
                             if hasattr(app, 'refresh'):
+                                debug_log("Forcing app refresh")
                                 app.refresh(layout=True)  # Force layout refresh
                         except Exception as callback_err:
                             debug_log(f"Error in UI callback: {str(callback_err)}")
                             logger.error(f"Error in UI callback: {str(callback_err)}")
-                            # Only print error to console if not OpenAI
-                            if not is_openai:
-                                print(f"Error updating UI: {str(callback_err)}")
+                            print(f"STREAM ERROR: Error updating UI: {str(callback_err)}")
                             
                         buffer = []
                         last_update = current_time
@@ -509,6 +555,23 @@ def resolve_model_id(model_id_or_name: str) -> str:
     input_lower = model_id_or_name.lower().strip()
     logger.info(f"Attempting to resolve model identifier: '{input_lower}'")
     
+    # Special case handling for common typos and model name variations
+    typo_corrections = {
+        "o4-mini": "04-mini",
+        "o1": "01",
+        "o1-mini": "01-mini",
+        "o1-preview": "01-preview",
+        "o4": "04",
+        "o4-preview": "04-preview",
+        "o4-vision": "04-vision"
+    }
+    
+    if input_lower in typo_corrections:
+        corrected = typo_corrections[input_lower]
+        logger.info(f"Converting '{input_lower}' to '{corrected}' (letter 'o' to zero '0')")
+        input_lower = corrected
+        model_id_or_name = corrected
+    
     # First, check if this is an OpenAI model - if so, return as-is to ensure correct provider
     if any(name in input_lower for name in ["gpt", "text-", "davinci"]):
         logger.info(f"Input '{input_lower}' appears to be an OpenAI model, returning as-is")

{chat_console-0.3.7.dist-info → chat_console-0.3.9.dist-info}/METADATA

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

chat_console-0.3.9.dist-info/RECORD

@@ -0,0 +1,24 @@
+app/__init__.py,sha256=EjqUVXPPqxbEvf8FYWy5IflGPyCeiFKVc6roYG8q77k,130
+app/config.py,sha256=KawltE7cK2bR9wbe1NSlepwWIjkiFw2bg3vbLmUnP38,7626
+app/database.py,sha256=nt8CVuDpy6zw8mOYqDcfUmNw611t7Ln7pz22M0b6-MI,9967
+app/main.py,sha256=KEkM7wMG7gQ4jFTRNWTTm7HQL5av6fVHFzg-uFyroZw,74654
+app/models.py,sha256=4-y9Lytay2exWPFi0FDlVeRL3K2-I7E-jBqNzTfokqY,2644
+app/utils.py,sha256=6za9f3USUiYvjTiwPDP7swPamRmlwApCYPyCKc9drNY,35228
+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=uBCdfie04zdp1UGePpz7m0XuOwMB71ynz9CulnKUDHg,64284
+app/api/openai.py,sha256=hLPr955tUx_2vwRuLP8Zrl3vu7kQZgUETi4cJuaYnFE,10810
+app/ui/__init__.py,sha256=RndfbQ1Tv47qdSiuQzvWP96lPS547SDaGE-BgOtiP_w,55
+app/ui/chat_interface.py,sha256=xJe3LoKbXJe1XHREevkMHL9ATpRg6y0ayu2hVGWELQM,19459
+app/ui/chat_list.py,sha256=WQTYVNSSXlx_gQal3YqILZZKL9UiTjmNMIDX2I9pAMM,11205
+app/ui/model_browser.py,sha256=pdblLVkdyVF0_Bo02bqbErGAtieyH-y6IfhMOPEqIso,71124
+app/ui/model_selector.py,sha256=ue3rbZfjVsjli-rJN5mfSqq23Ci7NshmTb4xWS-uG5k,18685
+app/ui/search.py,sha256=b-m14kG3ovqW1-i0qDQ8KnAqFJbi5b1FLM9dOnbTyIs,9763
+app/ui/styles.py,sha256=04AhPuLrOd2yenfRySFRestPeuTPeMLzhmMB67NdGvw,5615
+chat_console-0.3.9.dist-info/licenses/LICENSE,sha256=srHZ3fvcAuZY1LHxE7P6XWju2njRCHyK6h_ftEbzxSE,1057
+chat_console-0.3.9.dist-info/METADATA,sha256=hqzrcRA8zI4qKGLdUEp7j4Y9sLSsFA6lTyhdM4f1GHY,2921
+chat_console-0.3.9.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
+chat_console-0.3.9.dist-info/entry_points.txt,sha256=kkVdEc22U9PAi2AeruoKklfkng_a_aHAP6VRVwrAD7c,67
+chat_console-0.3.9.dist-info/top_level.txt,sha256=io9g7LCbfmTG1SFKgEOGXmCFB9uMP2H5lerm0HiHWQE,4
+chat_console-0.3.9.dist-info/RECORD,,

chat_console-0.3.7.dist-info/RECORD

@@ -1,24 +0,0 @@
-app/__init__.py,sha256=ZSZR6xIuPhvv1zB4p63eSeGQX8bTkhxBWk2Gn0peFaw,130
-app/config.py,sha256=KawltE7cK2bR9wbe1NSlepwWIjkiFw2bg3vbLmUnP38,7626
-app/database.py,sha256=nt8CVuDpy6zw8mOYqDcfUmNw611t7Ln7pz22M0b6-MI,9967
-app/main.py,sha256=clcRjXwySxVjrPtqvPOIfl7r8KbHVLZ1woxyEnvl3JI,72829
-app/models.py,sha256=4-y9Lytay2exWPFi0FDlVeRL3K2-I7E-jBqNzTfokqY,2644
-app/utils.py,sha256=htktBl1JucYEHo1WBrWkfdip4yzRtvyVl24Aaj445xA,32421
-app/api/__init__.py,sha256=A8UL84ldYlv8l7O-yKzraVFcfww86SgWfpl4p7R03-w,62
-app/api/anthropic.py,sha256=UpIP3CgAOUimdVyif41MhBOCAgOyFO8mX9SFQMKRAmc,12483
-app/api/base.py,sha256=eShCiZIcW3yeZLONt1xnkP0vU6v5MEaDj3YZ3xcPle8,7294
-app/api/ollama.py,sha256=EBEEKXbgAYWEg_zF5PO_UKO5l_aoU3J_7tfCj9e-fqs,61699
-app/api/openai.py,sha256=6ORruzuuZtIjME3WK-g7kXf7cBmM4td5Njv9JLaWh7E,9557
-app/ui/__init__.py,sha256=RndfbQ1Tv47qdSiuQzvWP96lPS547SDaGE-BgOtiP_w,55
-app/ui/chat_interface.py,sha256=TJlMzVmrKzr3t0JIhto0vKBvyik7gJ7UEyW3Vqbn3cE,17262
-app/ui/chat_list.py,sha256=WQTYVNSSXlx_gQal3YqILZZKL9UiTjmNMIDX2I9pAMM,11205
-app/ui/model_browser.py,sha256=pdblLVkdyVF0_Bo02bqbErGAtieyH-y6IfhMOPEqIso,71124
-app/ui/model_selector.py,sha256=ue3rbZfjVsjli-rJN5mfSqq23Ci7NshmTb4xWS-uG5k,18685
-app/ui/search.py,sha256=b-m14kG3ovqW1-i0qDQ8KnAqFJbi5b1FLM9dOnbTyIs,9763
-app/ui/styles.py,sha256=04AhPuLrOd2yenfRySFRestPeuTPeMLzhmMB67NdGvw,5615
-chat_console-0.3.7.dist-info/licenses/LICENSE,sha256=srHZ3fvcAuZY1LHxE7P6XWju2njRCHyK6h_ftEbzxSE,1057
-chat_console-0.3.7.dist-info/METADATA,sha256=eDQRUghh8Ihp8z38oAlI0___RBBDJHpLmhBGF0VgZ1w,2921
-chat_console-0.3.7.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
-chat_console-0.3.7.dist-info/entry_points.txt,sha256=kkVdEc22U9PAi2AeruoKklfkng_a_aHAP6VRVwrAD7c,67
-chat_console-0.3.7.dist-info/top_level.txt,sha256=io9g7LCbfmTG1SFKgEOGXmCFB9uMP2H5lerm0HiHWQE,4
-chat_console-0.3.7.dist-info/RECORD,,