chat-console 0.3.8__tar.gz → 0.3.91__tar.gz

{chat_console-0.3.8/chat_console.egg-info → chat_console-0.3.91}/PKG-INFO

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

chat_console-0.3.91/app/api/anthropic.py

@@ -0,0 +1,238 @@
+import anthropic
+import asyncio
+import logging
+from typing import List, Dict, Any, Optional, Generator, AsyncGenerator
+from .base import BaseModelClient
+from ..config import ANTHROPIC_API_KEY
+
+# 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':
+        """Create a new instance with async initialization."""
+        instance = cls()
+        instance.client = anthropic.AsyncAnthropic(api_key=ANTHROPIC_API_KEY)
+        return instance
+    
+    def _prepare_messages(self, messages: List[Dict[str, str]], style: Optional[str] = None) -> List[Dict[str, str]]:
+        """Prepare messages for Anthropic API"""
+        processed_messages = []
+        
+        # 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": "system",
+                    "content": message["content"]
+                })
+            else:
+                # 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": "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, 
+                           max_tokens: Optional[int] = None) -> str:
+        """Generate a text completion using Anthropic"""
+        processed_messages = self._prepare_messages(messages, style)
+        
+        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, 
+                            style: Optional[str] = None,
+                            temperature: float = 0.7, 
+                            max_tokens: Optional[int] = None) -> AsyncGenerator[str, None]:
+        """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
+            
+        processed_messages = self._prepare_messages(messages, style)
+        
+        try:
+            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
+            
+            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 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:
+            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("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"
+            }
+        ]
+        
+        return models

{chat_console-0.3.8 → chat_console-0.3.91}/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"""

{chat_console-0.3.8 → chat_console-0.3.91}/app/api/ollama.py

@@ -11,6 +11,14 @@ from .base import BaseModelClient
 # Set up logging
 logger = logging.getLogger(__name__)
 
+# Custom exception for Ollama API errors
+class OllamaApiError(Exception):
+    """Exception raised for errors in the Ollama API."""
+    def __init__(self, message: str, status_code: Optional[int] = None):
+        self.message = message
+        self.status_code = status_code
+        super().__init__(self.message)
+
 class OllamaClient(BaseModelClient):
     def __init__(self):
         from ..config import OLLAMA_BASE_URL
@@ -266,6 +274,29 @@ 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:
+                error_msg = f"Model '{model}' not found in available models. Available models include: {', '.join(available_model_names[:5])}"
+                if len(available_model_names) > 5:
+                    error_msg += f" and {len(available_model_names) - 5} more."
+                logger.error(error_msg)
+                raise OllamaApiError(error_msg)
+        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 +330,17 @@ 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}")
+                                    error_msg = f"Error: Model '{model}' not found on the Ollama server. Please check if the model name is correct or try pulling it first."
+                                    logger.error(error_msg)
+                                    # Instead of raising, yield the error message for user display
+                                    yield error_msg
+                                    return  # End the generation
+                                    
                                 raise aiohttp.ClientError("Model not ready")
                     except (aiohttp.ClientError, asyncio.TimeoutError) as e:
                         logger.info(f"Model cold start detected: {str(e)}")
@@ -326,6 +368,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
+                                    error_msg = f"Error: Model '{model}' not found in the Ollama registry. Please check if the model name is correct or try a different model."
+                                    logger.error(error_msg)
+                                    raise OllamaApiError(error_msg, status_code=404)
+                                    
                                 raise Exception("Failed to pull model")
                             logger.info("Model pulled successfully")
                             debug_log("Model pulled successfully")

{chat_console-0.3.8 → chat_console-0.3.91}/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:

{chat_console-0.3.8 → chat_console-0.3.91}/app/config.py

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

{chat_console-0.3.8 → chat_console-0.3.91}/app/main.py

@@ -20,10 +20,10 @@ file_handler = logging.FileHandler(debug_log_file)
 file_handler.setFormatter(logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s'))
 
 # Get the logger and add the handler
-debug_logger = logging.getLogger("chat-cli-debug")
+debug_logger = logging.getLogger()  # Root logger
 debug_logger.setLevel(logging.DEBUG)
 debug_logger.addHandler(file_handler)
-# Prevent propagation to the root logger (which would print to console)
+# CRITICAL: Force all output to the file, not stdout
 debug_logger.propagate = False
 
 # Add a convenience function to log to this file
@@ -1010,11 +1010,15 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
                 self._loading_animation_task.cancel()
             self._loading_animation_task = None
             try:
+                # Explicitly hide loading indicator
                 loading = self.query_one("#loading-indicator")
                 loading.add_class("hidden")
+                loading.remove_class("model-loading")  # Also remove model-loading class if present
+                self.refresh(layout=True)  # Force a refresh to ensure UI updates
                 self.query_one("#message-input").focus()
-            except Exception:
-                pass # Ignore UI errors during cleanup
+            except Exception as ui_err:
+                debug_log(f"Error hiding loading indicator: {str(ui_err)}")
+                log.error(f"Error hiding loading indicator: {str(ui_err)}")
 
     # Rename this method slightly to avoid potential conflicts and clarify purpose
     async def _handle_generation_result(self, worker: Worker[Optional[str]]) -> None:
@@ -1043,6 +1047,15 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
                 debug_log(f"Error in generation worker: {error}")
                 log.error(f"Error in generation worker: {error}")
                 
+                # Explicitly hide loading indicator
+                try:
+                    loading = self.query_one("#loading-indicator")
+                    loading.add_class("hidden")
+                    loading.remove_class("model-loading")  # Also remove model-loading class if present
+                except Exception as ui_err:
+                    debug_log(f"Error hiding loading indicator: {str(ui_err)}")
+                    log.error(f"Error hiding loading indicator: {str(ui_err)}")
+                
                 # Sanitize error message for UI display
                 error_str = str(error)
                 
@@ -1069,6 +1082,9 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
                 debug_log(f"Adding error message: {user_error}")
                 self.messages.append(Message(role="assistant", content=user_error))
                 await self.update_messages_ui()
+                
+                # Force a refresh to ensure UI updates
+                self.refresh(layout=True)
 
             elif worker.state == "success":
                 full_response = worker.result

{chat_console-0.3.8 → chat_console-0.3.91}/app/ui/chat_interface.py

@@ -120,54 +120,61 @@ class MessageDisplay(Static): # Inherit from Static instead of RichLog
         self.update(self._format_content(self.message.content))
         
     async def update_content(self, content: str) -> None:
-        """Update the message content using Static.update() with optimizations for streaming"""
-        # Debug print to verify method is being called with content
-        print(f"MessageDisplay.update_content called with content length: {len(content)}")
-        
-        # Quick unchanged content check to avoid unnecessary updates
-        if self.message.content == content:
-            print("Content unchanged, skipping update")
-            return
-            
-        # Special handling for "Thinking..." to ensure it gets replaced
-        if self.message.content == "Thinking..." and content:
-            print("Replacing 'Thinking...' with actual content")
-            # Force a complete replacement rather than an append
-            self.message.content = ""
-            # Add a debug print to confirm this branch is executed
-            print("CRITICAL FIX: Replacing 'Thinking...' placeholder with actual content")
-            
-        # Update the stored message object content
-        self.message.content = content
-        
-        # Format with fixed-width placeholder to minimize layout shifts
-        # This avoids text reflowing as new tokens arrive
-        formatted_content = self._format_content(content)
-        
-        # Use a direct update that forces refresh - critical fix for streaming
-        # This ensures content is immediately visible
-        print(f"Updating widget with formatted content length: {len(formatted_content)}")
-        self.update(formatted_content, refresh=True)
-        
-        # Force app-level refresh and scroll to ensure visibility
-        try:
-            # Always force app refresh for every update
-            if self.app:
-                # Force a full layout refresh to ensure content is visible
-                self.app.refresh(layout=True)
+        """Update the message content."""
+        import logging
+        logger = logging.getLogger(__name__)
+        logger.debug(f"MessageDisplay.update_content called with content length: {len(content)}")
+        
+        # Use a lock to prevent race conditions during updates
+        if not hasattr(self, '_update_lock'):
+            self._update_lock = asyncio.Lock()
+        
+        async with self._update_lock:
+            # For initial update from "Thinking..."
+            if self.message.content == "Thinking..." and content:
+                logger.debug("Replacing 'Thinking...' with initial content")
+                self.message.content = content  # Update the stored content
+                formatted = self._format_content(content)
+                self.update(formatted, refresh=True)
                 
-                # 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)
+                # Force a clean layout update
+                try:
+                    if self.app:
+                        self.app.refresh(layout=True)
+                        await asyncio.sleep(0.05)  # Small delay for layout to update
                         
-                # Add an additional refresh after scrolling
-                self.app.refresh(layout=True)
-        except Exception as e:
-            # Log the error and fallback to local refresh
-            print(f"Error refreshing app: {str(e)}")
-            self.refresh(layout=True)
+                        # Find container and scroll
+                        messages_container = self.app.query_one("#messages-container")
+                        if messages_container:
+                            messages_container.scroll_end(animate=False)
+                except Exception as e:
+                    logger.error(f"Error in initial UI update: {str(e)}")
+                return
+                
+            # Quick unchanged content check to avoid unnecessary updates
+            if self.message.content == content:
+                logger.debug("Content unchanged, skipping update")
+                return
+                
+            # For subsequent updates
+            if self.message.content != content:
+                self.message.content = content
+                formatted = self._format_content(content)
+                self.update(formatted, refresh=True)
+                
+                # Use a more targeted refresh approach
+                try:
+                    if self.app:
+                        self.app.refresh(layout=False)  # Lightweight refresh first
+                        # Find container and scroll
+                        messages_container = self.app.query_one("#messages-container")
+                        if messages_container:
+                            messages_container.scroll_end(animate=False)
+                            
+                        # Final full refresh only at end
+                        self.app.refresh(layout=True)
+                except Exception as e:
+                    logger.error(f"Error refreshing UI: {str(e)}")
         
     def _format_content(self, content: str) -> str:
         """Format message content with timestamp and handle markdown links"""
@@ -191,8 +198,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}"