chat-console 0.1.5__py3-none-any.whl → 0.1.6.dev1__py3-none-any.whl

app/api/ollama.py

@@ -161,6 +161,37 @@ class OllamaClient(BaseModelClient):
         
         while retries >= 0:
             try:
+                # First try a quick test request to check if model is loaded
+                async with aiohttp.ClientSession() as session:
+                    try:
+                        logger.info("Testing model availability...")
+                        async with session.post(
+                            f"{self.base_url}/api/generate",
+                            json={
+                                "model": model,
+                                "prompt": "test",
+                                "temperature": temperature,
+                                "stream": False
+                            },
+                            timeout=2
+                        ) as response:
+                            if response.status != 200:
+                                logger.warning(f"Model test request failed with status {response.status}")
+                                raise aiohttp.ClientError("Model not ready")
+                    except (aiohttp.ClientError, asyncio.TimeoutError) as e:
+                        logger.info(f"Model cold start detected: {str(e)}")
+                        # Model might need loading, try pulling it
+                        async with session.post(
+                            f"{self.base_url}/api/pull",
+                            json={"name": model},
+                            timeout=60
+                        ) as pull_response:
+                            if pull_response.status != 200:
+                                logger.error("Failed to pull model")
+                                raise Exception("Failed to pull model")
+                            logger.info("Model pulled successfully")
+                
+                # Now proceed with actual generation
                 async with aiohttp.ClientSession() as session:
                     logger.debug(f"Sending streaming request to {self.base_url}/api/generate")
                     async with session.post(
@@ -171,7 +202,7 @@ class OllamaClient(BaseModelClient):
                             "temperature": temperature,
                             "stream": True
                         },
-                        timeout=30
+                        timeout=60  # Longer timeout for actual generation
                     ) as response:
                         response.raise_for_status()
                         async for line in response.content:

app/main.py

@@ -520,43 +520,85 @@ class SimpleChatApp(App):
             # Add small delay to show thinking state
             await asyncio.sleep(0.5)
             
-            # Stream chunks to the UI
+            # Stream chunks to the UI with synchronization
+            update_lock = asyncio.Lock()
+            
             async def update_ui(content: str):
                 if not self.is_generating:
                     return
                 
-                try:
-                    # Clear thinking indicator on first content
-                    if assistant_message.content == "Thinking...":
-                        assistant_message.content = ""
-                    
-                    # Update message with full content so far
-                    assistant_message.content = content
-                    # Update UI with full content
-                    message_display.update_content(content)
-                    messages_container.scroll_end(animate=False)
-                    # Let the event loop process the update
-                    await asyncio.sleep(0)
-                except Exception as e:
-                    self.notify(f"Error updating UI: {str(e)}", severity="error")
+                async with update_lock:
+                    try:
+                        # Clear thinking indicator on first content
+                        if assistant_message.content == "Thinking...":
+                            assistant_message.content = ""
+                        
+                        # Update message with full content so far
+                        assistant_message.content = content
+                        # Update UI with full content
+                        await message_display.update_content(content)
+                        # Force a refresh and scroll
+                        self.refresh(layout=True)
+                        await asyncio.sleep(0.05)  # Longer delay for UI stability
+                        messages_container.scroll_end(animate=False)
+                        # Force another refresh to ensure content is visible
+                        self.refresh(layout=True)
+                    except Exception as e:
+                        logger.error(f"Error updating UI: {str(e)}")
                 
-            # Generate the response
-            full_response = await generate_streaming_response(
-                api_messages,
-                model,
-                style,
-                client,
-                update_ui
-            )
-            
-            # Save to database
-            if self.is_generating:  # Only save if not cancelled
-                self.db.add_message(
-                    self.current_conversation.id,
-                    "assistant",
-                    full_response
+            # Generate the response with timeout and cleanup
+            generation_task = None
+            try:
+                # Create a task for the response generation
+                generation_task = asyncio.create_task(
+                    generate_streaming_response(
+                        api_messages,
+                        model,
+                        style,
+                        client,
+                        update_ui
+                    )
                 )
                 
+                # Wait for response with timeout
+                full_response = await asyncio.wait_for(generation_task, timeout=60)  # Longer timeout
+                
+                # Save to database only if we got a complete response
+                if self.is_generating and full_response:
+                    self.db.add_message(
+                        self.current_conversation.id,
+                        "assistant",
+                        full_response
+                    )
+                    # Force a final refresh
+                    self.refresh(layout=True)
+                    await asyncio.sleep(0.1)  # Wait for UI to update
+                    
+            except asyncio.TimeoutError:
+                logger.error("Response generation timed out")
+                error_msg = "Response generation timed out. The model may be busy or unresponsive. Please try again."
+                self.notify(error_msg, severity="error")
+                
+                # Remove the incomplete message
+                if self.messages and self.messages[-1].role == "assistant":
+                    self.messages.pop()
+                
+                # Update UI to remove the incomplete message
+                await self.update_messages_ui()
+                
+            finally:
+                # Ensure task is properly cancelled and cleaned up
+                if generation_task:
+                    if not generation_task.done():
+                        generation_task.cancel()
+                        try:
+                            await generation_task
+                        except (asyncio.CancelledError, Exception) as e:
+                            logger.error(f"Error cleaning up generation task: {str(e)}")
+                    
+                # Force a final UI refresh
+                self.refresh(layout=True)
+                
         except Exception as e:
             self.notify(f"Error generating response: {str(e)}", severity="error")
             # Add error message

app/ui/chat_interface.py

@@ -3,6 +3,7 @@ import time
 import asyncio
 from datetime import datetime
 import re
+import logging
     
 from textual.app import ComposeResult
 from textual.containers import Container, ScrollableContainer, Vertical
@@ -16,6 +17,9 @@ from ..models import Message, Conversation
 from ..api.base import BaseModelClient
 from ..config import CONFIG
 
+# Set up logging
+logger = logging.getLogger(__name__)
+
 class MessageDisplay(RichLog):
     """Widget to display a single message"""
     
@@ -75,13 +79,15 @@ class MessageDisplay(RichLog):
         # Initial content
         self.write(self._format_content(self.message.content))
         
-    def update_content(self, content: str) -> None:
+    async def update_content(self, content: str) -> None:
         """Update the message content"""
         self.message.content = content
         self.clear()
         self.write(self._format_content(content))
         # Force a refresh after writing
         self.refresh(layout=True)
+        # Wait a moment for the layout to update
+        await asyncio.sleep(0.05)
         
     def _format_content(self, content: str) -> str:
         """Format message content with timestamp"""
@@ -252,13 +258,17 @@ class ChatInterface(Container):
             )
             messages_container.mount(self.current_message_display)
             
+            # Force a layout refresh and wait for it to complete
+            self.refresh(layout=True)
+            await asyncio.sleep(0.1)
+            
         # Save to conversation if exists
         if self.conversation and self.conversation.id:
             from ..database import ChatDatabase
             db = ChatDatabase()
             db.add_message(self.conversation.id, role, content)
             
-        self.scroll_to_bottom()
+        await self.scroll_to_bottom()
         
     async def send_message(self) -> None:
         """Send a message"""
@@ -318,10 +328,10 @@ class ChatInterface(Container):
             for message in self.messages:
                 display = MessageDisplay(message, highlight_code=CONFIG["highlight_code"])
                 messages_container.mount(display)
-                self.scroll_to_bottom()
-                await asyncio.sleep(0.01)  # Small delay to prevent UI freezing
+                await self.scroll_to_bottom()
+                await asyncio.sleep(0.05)  # Small delay to prevent UI freezing
                     
-        self.scroll_to_bottom()
+        await self.scroll_to_bottom()
         
         # Re-focus the input field after changing conversation
         self.query_one("#message-input").focus()
@@ -333,19 +343,24 @@ class ChatInterface(Container):
             self.query_one("#message-input").focus()
             
             # Scroll to bottom to ensure the latest messages are visible
-            self.scroll_to_bottom()
-        except Exception:
-            # Ignore errors during resize handling
-            pass
+            asyncio.create_task(self.scroll_to_bottom())
+        except Exception as e:
+            logger.error(f"Error handling resize: {str(e)}")
             
-    def scroll_to_bottom(self) -> None:
+    async def scroll_to_bottom(self) -> None:
         """Scroll to the bottom of the messages container"""
         try:
             messages_container = self.query_one("#messages-container")
+            # Force a layout refresh
+            self.refresh(layout=True)
+            # Wait a moment for layout to update
+            await asyncio.sleep(0.1)
+            # Scroll to bottom
             messages_container.scroll_end(animate=False)
-        except Exception:
-            # Container might not be available yet or scroll_end might not work
-            pass
+            # Force another refresh
+            self.refresh(layout=True)
+        except Exception as e:
+            logger.error(f"Error scrolling to bottom: {str(e)}")
         
     def watch_is_loading(self, is_loading: bool) -> None:
         """Watch the is_loading property"""

app/utils.py

@@ -1,5 +1,7 @@
 import os
 import json
+import time
+import asyncio
 import subprocess
 import logging
 from typing import Optional, Dict, Any, List
@@ -13,11 +15,33 @@ async def generate_streaming_response(messages: List[Dict], model: str, style: s
     """Generate a streaming response from the model"""
     logger.info(f"Starting streaming response with model: {model}")
     full_response = ""
+    buffer = []
+    last_update = time.time()
+    update_interval = 0.1  # Update UI every 100ms
+    
     try:
         async for chunk in client.generate_stream(messages, model, style):
             if chunk:  # Only process non-empty chunks
-                full_response += chunk
-                await callback(full_response)  # Send full response so far
+                buffer.append(chunk)
+                current_time = time.time()
+                
+                # Update UI if enough time has passed or buffer is large
+                if current_time - last_update >= update_interval or len(''.join(buffer)) > 100:
+                    new_content = ''.join(buffer)
+                    full_response += new_content
+                    await callback(full_response)
+                    buffer = []
+                    last_update = current_time
+                    
+                    # Small delay to let UI catch up
+                    await asyncio.sleep(0.05)
+        
+        # Send any remaining content
+        if buffer:
+            new_content = ''.join(buffer)
+            full_response += new_content
+            await callback(full_response)
+        
         logger.info("Streaming response completed")
         return full_response
     except Exception as e:

{chat_console-0.1.5.dist-info → chat_console-0.1.6.dev1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: chat-console
-Version: 0.1.5
+Version: 0.1.6.dev1
 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.1.5.dist-info → chat_console-0.1.6.dev1.dist-info}/RECORD

@@ -1,23 +1,23 @@
 app/__init__.py,sha256=u5X4kPcpqZ12ZLnhwwOCScNvftaknDTrb0DMXqR_iLc,130
 app/config.py,sha256=7C09kn2bmda9frTPfZ7f1JhagqHAZjGM5BYqZmhegYM,5190
 app/database.py,sha256=nt8CVuDpy6zw8mOYqDcfUmNw611t7Ln7pz22M0b6-MI,9967
-app/main.py,sha256=ZeLroiPrlGgXArL0Po545PB3SU6imkx2KATjld1hV6s,21996
+app/main.py,sha256=vVfCgdbfuHjXwSoPt0hfZ9Ee4tpat8MA2tNwXKj21wQ,24179
 app/models.py,sha256=4-y9Lytay2exWPFi0FDlVeRL3K2-I7E-jBqNzTfokqY,2644
-app/utils.py,sha256=tbMhutE3vg9seGstD5k8MyUhJo5XbJ17p64dl2wTqYY,3481
+app/utils.py,sha256=zK8aTPdadXomyG2Kgpi7WuC5XYwfShJj74bXWSLtyW0,4309
 app/api/__init__.py,sha256=A8UL84ldYlv8l7O-yKzraVFcfww86SgWfpl4p7R03-w,62
 app/api/anthropic.py,sha256=x5PmBXEKe_ow2NWk8XdqSPR0hLOdCc_ypY5QAySeA78,4234
 app/api/base.py,sha256=-6RSxSpqe-OMwkaq1wVWbu3pVkte-ZYy8rmdvt-Qh48,3953
-app/api/ollama.py,sha256=2Yqyc6d3lwShAx4j1A97y7iPZWLeMw-wumtnhvQzAxY,9869
+app/api/ollama.py,sha256=zFZ3g2sYncvMgcvx92jTCLkigIaDvTuhILcLiCrwisc,11640
 app/api/openai.py,sha256=1fYgFXXL6yj_7lQ893Yj28RYG4M8d6gt_q1gzhhjcig,3641
 app/ui/__init__.py,sha256=RndfbQ1Tv47qdSiuQzvWP96lPS547SDaGE-BgOtiP_w,55
-app/ui/chat_interface.py,sha256=wFmCiSvwqp8Jia3nkMUxrYAou7Hr3UAqGhTvZoClVL8,11548
+app/ui/chat_interface.py,sha256=lzBpFLTKhGHCKlJaTl5NIjUm15tly7ZQKmp74QzYdVk,12142
 app/ui/chat_list.py,sha256=WQTYVNSSXlx_gQal3YqILZZKL9UiTjmNMIDX2I9pAMM,11205
 app/ui/model_selector.py,sha256=xCuaohgYvebgP0Eel6-XzUn-7Y0SrJUArdTr-CDBZXc,12840
 app/ui/search.py,sha256=b-m14kG3ovqW1-i0qDQ8KnAqFJbi5b1FLM9dOnbTyIs,9763
 app/ui/styles.py,sha256=04AhPuLrOd2yenfRySFRestPeuTPeMLzhmMB67NdGvw,5615
-chat_console-0.1.5.dist-info/LICENSE,sha256=srHZ3fvcAuZY1LHxE7P6XWju2njRCHyK6h_ftEbzxSE,1057
-chat_console-0.1.5.dist-info/METADATA,sha256=zS5hPtT7INca9w40E2gSFn5fpkD2zz9v0x1JnnsU7HI,2899
-chat_console-0.1.5.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
-chat_console-0.1.5.dist-info/entry_points.txt,sha256=kkVdEc22U9PAi2AeruoKklfkng_a_aHAP6VRVwrAD7c,67
-chat_console-0.1.5.dist-info/top_level.txt,sha256=io9g7LCbfmTG1SFKgEOGXmCFB9uMP2H5lerm0HiHWQE,4
-chat_console-0.1.5.dist-info/RECORD,,
+chat_console-0.1.6.dev1.dist-info/LICENSE,sha256=srHZ3fvcAuZY1LHxE7P6XWju2njRCHyK6h_ftEbzxSE,1057
+chat_console-0.1.6.dev1.dist-info/METADATA,sha256=dDkAEFkFOyYQpOMV08KTMQwMQRI59kZt-nH7QP9HvUY,2904
+chat_console-0.1.6.dev1.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
+chat_console-0.1.6.dev1.dist-info/entry_points.txt,sha256=kkVdEc22U9PAi2AeruoKklfkng_a_aHAP6VRVwrAD7c,67
+chat_console-0.1.6.dev1.dist-info/top_level.txt,sha256=io9g7LCbfmTG1SFKgEOGXmCFB9uMP2H5lerm0HiHWQE,4
+chat_console-0.1.6.dev1.dist-info/RECORD,,