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

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

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

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

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

@@ -121,11 +121,23 @@ 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"""
+        # 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
             
-        # Update the stored message object content first
+        # 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
@@ -134,6 +146,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
+        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
@@ -148,6 +161,9 @@ class MessageDisplay(Static): # Inherit from Static instead of RichLog
                 for container in containers:
                     if hasattr(container, 'scroll_end'):
                         container.scroll_end(animate=False)
+                        
+                # 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)}")
@@ -157,6 +173,11 @@ class MessageDisplay(Static): # Inherit from Static instead of RichLog
         """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(

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

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

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