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

app/api/anthropic.py

@@ -7,7 +7,14 @@ from ..utils import resolve_model_id  # Import the resolve_model_id function
 
 class AnthropicClient(BaseModelClient):
     def __init__(self):
-        self.client = anthropic.AsyncAnthropic(api_key=ANTHROPIC_API_KEY)
+        self.client = None  # Initialize in create()
+
+    @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 Claude API"""
@@ -137,86 +144,110 @@ class AnthropicClient(BaseModelClient):
         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...")
-            # The Anthropic Python SDK might not have a direct high-level method for listing models yet.
-            # We might need to use the underlying HTTP client or make a direct request.
-            # Let's assume for now the SDK client *does* have a way, like self.client.models.list()
-            # If this fails, we'd need to implement a direct HTTP GET request.
-            # response = await self.client.models.list() # Hypothetical SDK method
-
-            # --- Alternative: Direct HTTP Request using httpx (if client exposes it) ---
-            # Check if the client has an internal http_client we can use
+            
+            # 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
+            
+            # Try direct HTTP request if client exposes the underlying HTTP client
             if hasattr(self.client, '_client') and hasattr(self.client._client, 'get'):
-                 response = await self.client._client.get(
-                     "/v1/models",
-                     headers={"anthropic-version": "2023-06-01"} # Add required version header
-                 )
-                 response.raise_for_status() # Raise HTTP errors
-                 models_data = response.json()
-                 debug_log(f"Anthropic: API response received: {models_data}")
-                 if 'data' in models_data and isinstance(models_data['data'], list):
-                      # Format the response as expected: list of {"id": ..., "name": ...}
-                      formatted_models = [
-                          {"id": model.get("id"), "name": model.get("display_name", model.get("id"))}
-                          for model in models_data['data']
-                          if model.get("id") # Ensure model has an ID
-                      ]
-                      # Log each model ID clearly for debugging
-                      debug_log(f"Anthropic: Available models from API:")
-                      for model in formatted_models:
-                          debug_log(f"  - ID: {model.get('id')}, Name: {model.get('name')}")
-                      return formatted_models
-                 else:
-                      debug_log("Anthropic: Unexpected API response format for models.")
-                      return []
-            else:
-                 debug_log("Anthropic: Client does not expose HTTP client for model listing. Returning empty list.")
-                 return [] # Cannot fetch dynamically
+                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)}")
-            # Fallback to a minimal hardcoded list in case of API error
-            # Include Claude 3.7 Sonnet with the correct full ID
-            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"},  # Add Claude 3.7 Sonnet
-            ]
-            debug_log("Anthropic: Using fallback model list:")
-            for model in fallback_models:
-                debug_log(f"  - ID: {model['id']}, Name: {model['name']}")
+            debug_log("Anthropic: Using fallback model list")
             return fallback_models
 
-    # Keep this synchronous for now, but make it call the async fetcher
-    # Note: This is slightly awkward. Ideally, config loading would be async.
-    # For now, we'll run the async fetcher within the sync method using asyncio.run()
-    # This is NOT ideal for performance but avoids larger refactoring of config loading.
     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"},
+        ]
+        
         try:
-            # Run the async fetcher method synchronously
-            models = asyncio.run(self._fetch_models_from_api())
-            return models
-        except RuntimeError as e:
-             # Handle cases where asyncio.run can't be called (e.g., already in an event loop)
-             # This might happen during app runtime if called again. Fallback needed.
-             try:
-                 from app.main import debug_log
-             except ImportError:
-                 debug_log = lambda msg: None
-             debug_log(f"Anthropic: Cannot run async model fetch synchronously ({e}). Falling back to hardcoded list.")
-             # Use the same fallback list as in _fetch_models_from_api
-             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"},  # Add Claude 3.7 Sonnet
-             ]
-             debug_log("Anthropic: Using fallback model list in get_available_models:")
-             for model in fallback_models:
-                 debug_log(f"  - ID: {model['id']}, Name: {model['name']}")
-             return fallback_models
+            # 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

app/api/base.py

@@ -71,7 +71,7 @@ class BaseModelClient(ABC):
             return None
             
     @staticmethod
-    def get_client_for_model(model_name: str) -> 'BaseModelClient':
+    async def get_client_for_model(model_name: str) -> 'BaseModelClient':
         """Factory method to get appropriate client for model"""
         from ..config import CONFIG, AVAILABLE_PROVIDERS
         from .anthropic import AnthropicClient
@@ -118,10 +118,10 @@ class BaseModelClient(ABC):
         
         # Return appropriate client
         if provider == "ollama":
-            return OllamaClient()
+            return await OllamaClient.create()
         elif provider == "openai":
-            return OpenAIClient()
+            return await OpenAIClient.create()
         elif provider == "anthropic":
-            return AnthropicClient()
+            return await AnthropicClient.create()
         else:
             raise ValueError(f"Unknown provider: {provider}")

app/api/ollama.py

@@ -3,7 +3,6 @@ import asyncio
 import json
 import logging
 import os
-import time
 from datetime import datetime, timedelta
 from pathlib import Path
 from typing import List, Dict, Any, Optional, Generator, AsyncGenerator
@@ -15,7 +14,6 @@ logger = logging.getLogger(__name__)
 class OllamaClient(BaseModelClient):
     def __init__(self):
         from ..config import OLLAMA_BASE_URL
-        from ..utils import ensure_ollama_running
         self.base_url = OLLAMA_BASE_URL.rstrip('/')
         logger.info(f"Initializing Ollama client with base URL: {self.base_url}")
         
@@ -27,10 +25,18 @@ class OllamaClient(BaseModelClient):
         
         # Path to the cached models file
         self.models_cache_path = Path(__file__).parent.parent / "data" / "ollama-models.json"
+
+    @classmethod
+    async def create(cls) -> 'OllamaClient':
+        """Factory method to create and initialize an OllamaClient instance"""
+        from ..utils import ensure_ollama_running
+        client = cls()
         
         # Try to start Ollama if not running
-        if not ensure_ollama_running():
+        if not await ensure_ollama_running():
             raise Exception(f"Failed to start Ollama server. Please ensure Ollama is installed and try again.")
+            
+        return client
         
     def _prepare_messages(self, messages: List[Dict[str, str]], style: Optional[str] = None) -> str:
         """Convert chat messages to Ollama format"""
@@ -363,6 +369,10 @@ class OllamaClient(BaseModelClient):
                     
                     # Use a simpler async iteration pattern that's less error-prone
                     debug_log("Starting to process response stream")
+                    
+                    # Set a flag to track if we've yielded any content
+                    has_yielded_content = False
+                    
                     async for line in response.content:
                         # Check cancellation periodically
                         if self._active_stream_session is None:
@@ -372,31 +382,38 @@ class OllamaClient(BaseModelClient):
                         try:
                             # Process the chunk
                             if line:
-                                chunk = line.decode().strip()
                                 chunk_str = line.decode().strip()
                                 # Check if it looks like JSON before trying to parse
                                 if chunk_str.startswith('{') and chunk_str.endswith('}'):
                                     try:
                                         data = json.loads(chunk_str)
                                         if isinstance(data, dict) and "response" in data:
-                                            chunk_length = len(data["response"]) if data["response"] else 0
-                                            debug_log(f"Yielding chunk of length: {chunk_length}")
-                                            yield data["response"]
+                                            response_text = data["response"]
+                                            if response_text:  # Only yield non-empty responses
+                                                has_yielded_content = True
+                                                chunk_length = len(response_text)
+                                                # Only log occasionally to reduce console spam
+                                                if chunk_length % 20 == 0:
+                                                    debug_log(f"Yielding chunk of length: {chunk_length}")
+                                                yield response_text
                                         else:
-                                            debug_log(f"JSON chunk missing 'response' key: {chunk_str}")
+                                            debug_log(f"JSON chunk missing 'response' key: {chunk_str[:100]}")
                                     except json.JSONDecodeError:
-                                        debug_log(f"JSON decode error for chunk: {chunk_str}")
+                                        debug_log(f"JSON decode error for chunk: {chunk_str[:100]}")
                                 else:
                                     # Log unexpected non-JSON lines but don't process them
-                                    if chunk_str: # Avoid logging empty lines
-                                        debug_log(f"Received unexpected non-JSON line: {chunk_str}")
-                                # Continue processing next line regardless of parsing success/failure of current line
-                                continue
+                                    if chunk_str and len(chunk_str) > 5:  # Avoid logging empty or tiny lines
+                                        debug_log(f"Received unexpected non-JSON line: {chunk_str[:100]}")
                         except Exception as chunk_err:
                             debug_log(f"Error processing chunk: {str(chunk_err)}")
                             # Continue instead of breaking to try processing more chunks
                             continue
                     
+                    # If we didn't yield any content, yield a default message
+                    if not has_yielded_content:
+                        debug_log("No content was yielded from stream, providing fallback response")
+                        yield "I'm sorry, but I couldn't generate a response. Please try again or try a different model."
+                    
                     logger.info("Streaming completed successfully")
                     debug_log("Streaming completed successfully")
                     return

app/api/openai.py

@@ -1,11 +1,19 @@
 from openai import AsyncOpenAI
+import asyncio
 from typing import List, Dict, Any, Optional, Generator, AsyncGenerator
 from .base import BaseModelClient
 from ..config import OPENAI_API_KEY
 
 class OpenAIClient(BaseModelClient):
     def __init__(self):
-        self.client = AsyncOpenAI(api_key=OPENAI_API_KEY)
+        self.client = None  # Initialize in create()
+
+    @classmethod
+    async def create(cls) -> 'OpenAIClient':
+        """Create a new instance with async initialization."""
+        instance = cls()
+        instance.client = AsyncOpenAI(api_key=OPENAI_API_KEY)
+        return instance
     
     def _prepare_messages(self, messages: List[Dict[str, str]], style: Optional[str] = None) -> List[Dict[str, str]]:
         """Prepare messages for OpenAI API"""
@@ -77,41 +85,87 @@ class OpenAIClient(BaseModelClient):
                         debug_log(f"OpenAI: skipping invalid message: {m}")
                 
                 debug_log(f"OpenAI: prepared {len(api_messages)} valid messages")
+                
+                # Check for empty or very short prompts and enhance them slightly
+                # This helps with the "hi" case where OpenAI might not generate a meaningful response
+                if api_messages and len(api_messages) > 0:
+                    last_message = api_messages[-1]
+                    if last_message["role"] == "user" and len(last_message["content"].strip()) <= 3:
+                        debug_log(f"OpenAI: Enhancing very short user prompt: '{last_message['content']}'")
+                        last_message["content"] = f"{last_message['content']} - Please respond conversationally."
+                        debug_log(f"OpenAI: Enhanced to: '{last_message['content']}'")
+                
             except Exception as msg_error:
                 debug_log(f"OpenAI: error preparing messages: {str(msg_error)}")
                 # Fallback to a simpler message format if processing fails
                 api_messages = [{"role": "user", "content": "Please respond to my request."}]
             
             debug_log("OpenAI: requesting stream")
-            stream = await self.client.chat.completions.create(
-                model=model,
-                messages=api_messages,
-                temperature=temperature,
-                max_tokens=max_tokens,
-                stream=True,
-            )
             
-            debug_log("OpenAI: stream created successfully, processing chunks")
-            async for chunk in stream:
+            # Use more robust error handling with retry for connection issues
+            max_retries = 2
+            retry_count = 0
+            
+            while retry_count <= max_retries:
                 try:
-                    if chunk.choices and hasattr(chunk.choices[0], 'delta') and hasattr(chunk.choices[0].delta, 'content'):
-                        content = chunk.choices[0].delta.content
-                        if content is not None:
-                            # Ensure we're returning a string
-                            text = str(content)
-                            debug_log(f"OpenAI: yielding chunk of length: {len(text)}")
-                            yield text
-                        else:
-                            debug_log("OpenAI: skipping None content chunk")
-                    else:
-                        debug_log("OpenAI: skipping chunk with missing content")
-                except Exception as chunk_error:
-                    debug_log(f"OpenAI: error processing chunk: {str(chunk_error)}")
-                    # Skip problematic chunks but continue processing
-                    continue
+                    stream = await self.client.chat.completions.create(
+                        model=model,
+                        messages=api_messages,
+                        temperature=temperature,
+                        max_tokens=max_tokens,
+                        stream=True,
+                    )
+                    debug_log("OpenAI: stream created successfully")
+                    
+                    # Yield a small padding token at the beginning for very short prompts
+                    # This ensures the UI sees immediate content updates
+                    if any(m["role"] == "user" and len(m["content"].strip()) <= 3 for m in api_messages):
+                        debug_log("OpenAI: Adding initial padding token for short message")
+                        yield ""  # Empty string to trigger UI update cycle
                     
+                    # Process stream chunks
+                    chunk_count = 0
+                    debug_log("OpenAI: starting to process chunks")
+                    
+                    async for chunk in stream:
+                        chunk_count += 1
+                        try:
+                            if chunk.choices and hasattr(chunk.choices[0], 'delta') and hasattr(chunk.choices[0].delta, 'content'):
+                                content = chunk.choices[0].delta.content
+                                if content is not None:
+                                    # Ensure we're returning a string
+                                    text = str(content)
+                                    debug_log(f"OpenAI: yielding chunk {chunk_count} of length: {len(text)}")
+                                    yield text
+                                else:
+                                    debug_log(f"OpenAI: skipping None content chunk {chunk_count}")
+                            else:
+                                debug_log(f"OpenAI: skipping chunk {chunk_count} with missing content")
+                        except Exception as chunk_error:
+                            debug_log(f"OpenAI: error processing chunk {chunk_count}: {str(chunk_error)}")
+                            # Skip problematic chunks but continue processing
+                            continue
+                    
+                    debug_log(f"OpenAI: stream completed successfully with {chunk_count} chunks")
+                    
+                    # If we reach this point, we've successfully processed the stream
+                    break
+                    
+                except Exception as e:
+                    debug_log(f"OpenAI: error in attempt {retry_count+1}/{max_retries+1}: {str(e)}")
+                    retry_count += 1
+                    if retry_count <= max_retries:
+                        debug_log(f"OpenAI: retrying after error (attempt {retry_count+1})")
+                        # Simple exponential backoff
+                        await asyncio.sleep(1 * retry_count)
+                    else:
+                        debug_log("OpenAI: max retries reached, raising exception")
+                        raise Exception(f"OpenAI streaming error after {max_retries+1} attempts: {str(e)}")
+                        
         except Exception as e:
             debug_log(f"OpenAI: 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"OpenAI streaming error: {str(e)}")
     
     def get_available_models(self) -> List[Dict[str, Any]]:

app/main.py

@@ -6,6 +6,7 @@ import os
 import asyncio
 import typer
 import logging
+import time
 from typing import List, Optional, Callable, Awaitable
 from datetime import datetime
 
@@ -22,6 +23,8 @@ file_handler.setFormatter(logging.Formatter('%(asctime)s - %(name)s - %(levelnam
 debug_logger = logging.getLogger("chat-cli-debug")
 debug_logger.setLevel(logging.DEBUG)
 debug_logger.addHandler(file_handler)
+# Prevent propagation to the root logger (which would print to console)
+debug_logger.propagate = False
 
 # Add a convenience function to log to this file
 def debug_log(message):
@@ -161,6 +164,15 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
     TITLE = "Chat Console"
     SUB_TITLE = "AI Chat Interface" # Keep SimpleChatApp SUB_TITLE
     DARK = True # Keep SimpleChatApp DARK
+    
+    # Add better terminal handling to fix UI glitches
+    SCREENS = {}
+    
+    # Force full screen mode and prevent background terminal showing through
+    FULL_SCREEN = True
+    
+    # Force capturing all mouse events for better stability
+    CAPTURE_MOUSE = True
 
     # Ensure the log directory exists in a standard cache location
     log_dir = os.path.expanduser("~/.cache/chat-cli")
@@ -424,7 +436,7 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
             # Check for available models # Keep SimpleChatApp on_mount
             from app.api.ollama import OllamaClient # Keep SimpleChatApp on_mount
             try: # Keep SimpleChatApp on_mount
-                ollama = OllamaClient() # Keep SimpleChatApp on_mount
+                ollama = await OllamaClient.create() # Keep SimpleChatApp on_mount
                 models = await ollama.get_available_models() # Keep SimpleChatApp on_mount
                 if not models: # Keep SimpleChatApp on_mount
                     api_issues.append("- No Ollama models found") # Keep SimpleChatApp on_mount
@@ -511,7 +523,7 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
                 # Get the client for the current model first and cancel the connection
                 try:
                     model = self.selected_model
-                    client = BaseModelClient.get_client_for_model(model)
+                    client = await BaseModelClient.get_client_for_model(model)
                     
                     # Call the client's cancel method if it's supported
                     if hasattr(client, 'cancel_stream'):
@@ -581,19 +593,21 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
         messages_container = self.query_one("#messages-container") # Keep SimpleChatApp update_messages_ui
         messages_container.remove_children() # Keep SimpleChatApp update_messages_ui
 
-        # Batch add all messages first without scrolling or refreshing between each mount
-        # This avoids unnecessary layout shifts while adding messages
-        for message in self.messages: # Keep SimpleChatApp update_messages_ui
-            display = MessageDisplay(message, highlight_code=CONFIG["highlight_code"]) # Keep SimpleChatApp update_messages_ui
-            messages_container.mount(display) # Keep SimpleChatApp update_messages_ui
+        # Temporarily disable automatic refresh while mounting messages
+        # This avoids excessive layout calculations and reduces flickering
+        with self.batch_update():
+            # Batch add all messages first without any refresh/layout
+            for message in self.messages: # Keep SimpleChatApp update_messages_ui
+                display = MessageDisplay(message, highlight_code=CONFIG["highlight_code"]) # Keep SimpleChatApp update_messages_ui
+                messages_container.mount(display) # Keep SimpleChatApp update_messages_ui
         
-        # Perform a single refresh and scroll after mounting all messages
-        # This significantly reduces the visual bouncing effect
-        # A small delay before scrolling helps ensure stable layout
-        await asyncio.sleep(0.05)  # Single delay after all messages are mounted
+        # A small delay after mounting all messages helps with layout stability
+        await asyncio.sleep(0.05)
+        
+        # Scroll after all messages are added without animation
         messages_container.scroll_end(animate=False) # Keep SimpleChatApp update_messages_ui
         
-        # Use layout=False refresh if possible to further reduce bouncing
+        # Minimal refresh without full layout recalculation
         self.refresh(layout=False)
 
     async def on_input_submitted(self, event: Input.Submitted) -> None: # Keep SimpleChatApp on_input_submitted
@@ -630,9 +644,10 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
         await self.update_messages_ui()
 
         # If this is the first message and dynamic titles are enabled, generate one
-        if is_first_message and self.current_conversation and CONFIG.get("generate_dynamic_titles", True):
+        # Only attempt title generation if the message has sufficient content (at least 3 characters)
+        if is_first_message and self.current_conversation and CONFIG.get("generate_dynamic_titles", True) and len(content) >= 3:
             log("First message detected, generating title...")
-            debug_log("First message detected, attempting to generate conversation title")
+            debug_log(f"First message detected with length {len(content)}, generating conversation title")
             title_generation_in_progress = True # Use a local flag
             loading = self.query_one("#loading-indicator")
             loading.remove_class("hidden") # Show loading for title gen
@@ -656,7 +671,7 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
                         # Last resort - check for a common Ollama model
                         try:
                             from app.api.ollama import OllamaClient
-                            ollama = OllamaClient()
+                            ollama = await OllamaClient.create()
                             models = await ollama.get_available_models()
                             if models and len(models) > 0:
                                 debug_log(f"Found {len(models)} Ollama models, using first one")
@@ -670,7 +685,7 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
                             debug_log("Final fallback to llama3")
 
                 debug_log(f"Getting client for model: {model}")
-                client = BaseModelClient.get_client_for_model(model)
+                client = await BaseModelClient.get_client_for_model(model)
                 
                 if client is None:
                     debug_log(f"No client available for model: {model}, trying to initialize")
@@ -679,7 +694,7 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
                     if client_type:
                         debug_log(f"Found client type {client_type.__name__} for {model}, initializing")
                         try:
-                            client = client_type()
+                            client = await client_type.create()
                             debug_log("Client initialized successfully")
                         except Exception as init_err:
                             debug_log(f"Error initializing client: {str(init_err)}")
@@ -689,12 +704,12 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
                         # Try a different model as last resort
                         if OPENAI_API_KEY:
                             from app.api.openai import OpenAIClient
-                            client = OpenAIClient()
+                            client = await OpenAIClient.create()
                             model = "gpt-3.5-turbo"
                             debug_log("Falling back to OpenAI for title generation")
                         elif ANTHROPIC_API_KEY:
                             from app.api.anthropic import AnthropicClient
-                            client = AnthropicClient()
+                            client = await AnthropicClient.create()
                             model = "claude-instant-1.2"
                             debug_log("Falling back to Anthropic for title generation")
                         else:
@@ -811,7 +826,7 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
                 else:
                     # Check for a common Ollama model
                     try:
-                        ollama = OllamaClient()
+                        ollama = await OllamaClient.create()
                         models = await ollama.get_available_models()
                         if models and len(models) > 0:
                             debug_log(f"Found {len(models)} Ollama models, using first one")
@@ -856,7 +871,7 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
             # Get appropriate client
             debug_log(f"Getting client for model: {model}")
             try:
-                client = BaseModelClient.get_client_for_model(model)
+                client = await BaseModelClient.get_client_for_model(model)
                 debug_log(f"Client: {client.__class__.__name__ if client else 'None'}")
                 
                 if client is None:
@@ -866,7 +881,7 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
                     if client_type:
                         debug_log(f"Found client type {client_type.__name__} for {model}, initializing")
                         try:
-                            client = client_type()
+                            client = await client_type.create()
                             debug_log(f"Successfully initialized {client_type.__name__}")
                         except Exception as init_err:
                             debug_log(f"Error initializing client: {str(init_err)}")
@@ -876,12 +891,12 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
                         # Try a different model as last resort
                         if OPENAI_API_KEY:
                             from app.api.openai import OpenAIClient
-                            client = OpenAIClient()
+                            client = await OpenAIClient.create()
                             model = "gpt-3.5-turbo"
                             debug_log("Falling back to OpenAI client")
                         elif ANTHROPIC_API_KEY:
                             from app.api.anthropic import AnthropicClient
-                            client = AnthropicClient()
+                            client = await AnthropicClient.create()
                             model = "claude-instant-1.2"
                             debug_log("Falling back to Anthropic client")
                         else:
@@ -907,6 +922,7 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
 
             # Stream chunks to the UI with synchronization
             update_lock = asyncio.Lock()
+            last_refresh_time = time.time()  # Initialize refresh throttling timer
 
             async def update_ui(content: str):
                 # This function remains the same, called by the worker
@@ -914,6 +930,9 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
                     debug_log("update_ui called but is_generating is False, returning.")
                     return
 
+                # Make last_refresh_time accessible in inner scope
+                nonlocal last_refresh_time
+                
                 async with update_lock:
                     try:
                         # Clear thinking indicator on first content
@@ -926,21 +945,40 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
 
                         # Update UI with the content - this no longer triggers refresh itself
                         await message_display.update_content(content)
+                        
+                        # Force a refresh after each update to ensure content is visible
+                        # This is critical for streaming to work properly
+                        self.refresh(layout=False)
 
-                        # Throttle UI updates to reduce visual jitter and improve performance
-                        # Only refresh visually every ~5 tokens (estimated by content length changes)
+                        # Scroll after each content update to ensure it's visible
+                        messages_container.scroll_end(animate=False)
+                        
+                        # Much more aggressive throttling of UI updates to eliminate visual jitter
+                        # By using a larger modulo value, we significantly reduce refresh frequency
+                        # This improves stability at the cost of slightly choppier animations
                         content_length = len(content)
+                        
+                        # Define some key refresh points - more frequent than before
+                        new_paragraph = content.endswith("\n") and content.count("\n") > 0
+                        code_block = "```" in content
                         do_refresh = (
-                            content_length < 20 or  # Always refresh for the first few tokens
-                            content_length % 16 == 0 or  # Then periodically
-                            content.endswith("\n")  # And on newlines
+                            content_length < 10 or  # More frequent on first few tokens
+                            content_length % 32 == 0 or  # More frequent periodic updates (32 vs 64)
+                            new_paragraph or  # Refresh on paragraph breaks
+                            code_block  # Refresh when code blocks are detected
                         )
                         
-                        if do_refresh:
-                            # Only scroll without full layout recalculation
+                        # Check if it's been enough time since last refresh (reduced to 200ms from 250ms)
+                        current_time = time.time()
+                        time_since_refresh = current_time - last_refresh_time
+                        
+                        if do_refresh and time_since_refresh > 0.2:
+                            # Store the time we did the refresh
+                            last_refresh_time = current_time
+                            # Ensure content is still visible by scrolling
                             messages_container.scroll_end(animate=False)
-                            # Light refresh without full layout recalculation
-                            self.refresh(layout=False)
+                            # Force a more thorough refresh periodically
+                            self.refresh(layout=True)
                     except Exception as e:
                         debug_log(f"Error updating UI: {str(e)}")
                         log.error(f"Error updating UI: {str(e)}")
@@ -1029,6 +1067,21 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
                     # Update the final message object content (optional, UI should be up-to-date)
                     if self.messages and self.messages[-1].role == "assistant":
                         self.messages[-1].content = full_response
+                        
+                    # Force a UI refresh with the message display to ensure it's fully rendered
+                    try:
+                        # Get the message display for the assistant message
+                        messages_container = self.query_one("#messages-container")
+                        message_displays = messages_container.query("MessageDisplay")
+                        # Check if we found any message displays
+                        if message_displays and len(message_displays) > 0:
+                            # Get the last message display which should be our assistant message
+                            last_message_display = message_displays[-1]
+                            debug_log("Forcing final content update on message display")
+                            # Force a final content update
+                            await last_message_display.update_content(full_response)
+                    except Exception as disp_err:
+                        debug_log(f"Error updating final message display: {str(disp_err)}")
                 else:
                     debug_log("Worker finished successfully but response was empty or invalid.")
                     # Handle case where 'Thinking...' might still be the last message
@@ -1036,11 +1089,24 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
                          self.messages.pop() # Remove 'Thinking...' if no content arrived
                          await self.update_messages_ui()
 
-                # Final UI refresh with minimal layout recalculation
-                # Use layout=False to prevent UI jumping at the end
-                self.refresh(layout=False)
-                await asyncio.sleep(0.1)  # Allow UI to stabilize
+                # Force a full UI refresh to ensure content is visible
                 messages_container = self.query_one("#messages-container")
+                
+                # Sequence of UI refreshes to ensure content is properly displayed
+                # 1. First do a lightweight refresh
+                self.refresh(layout=False)
+                
+                # 2. Short delay to allow the UI to process
+                await asyncio.sleep(0.1)  
+                
+                # 3. Ensure we're scrolled to the end
+                messages_container.scroll_end(animate=False)
+                
+                # 4. Full layout refresh
+                self.refresh(layout=True)
+                
+                # 5. Final delay and scroll to ensure everything is visible
+                await asyncio.sleep(0.1)
                 messages_container.scroll_end(animate=False)
 
         except Exception as e:

app/ui/chat_interface.py

@@ -1,5 +1,4 @@
 from typing import List, Dict, Any, Optional, Callable, Awaitable
-import time
 import asyncio
 from datetime import datetime
 import re
@@ -66,9 +65,9 @@ class MessageDisplay(Static): # Inherit from Static instead of RichLog
         padding: 1;
         text-wrap: wrap; /* Explicitly enable text wrapping via CSS */
         content-align: left top; /* Anchor content to top-left */
-        overflow-y: visible; /* Allow content to expand */
+        overflow-y: auto; /* Changed from 'visible' to valid 'auto' value */
         box-sizing: border-box; /* Include padding in size calculations */
-        transitions: none; /* Disable any transitions that might cause animation */
+        transition: none; /* Fixed property name from 'transitions' to 'transition' */
     }
     
     MessageDisplay.user-message {
@@ -121,7 +120,11 @@ 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()"""
+        """Update the message content using Static.update() with optimizations for streaming"""
+        # Quick unchanged content check to avoid unnecessary updates
+        if self.message.content == content:
+            return
+            
         # Update the stored message object content first
         self.message.content = content
         
@@ -129,16 +132,56 @@ class MessageDisplay(Static): # Inherit from Static instead of RichLog
         # This avoids text reflowing as new tokens arrive
         formatted_content = self._format_content(content)
         
-        # Update Static widget with minimal refresh
-        self.update(formatted_content)
+        # Use minimal update that doesn't trigger a refresh
+        # This allows parent to control refresh timing and avoid flickering
+        self.update(formatted_content, refresh=False)
         
-        # Important: Don't call refresh() here - let the parent handle timing
-        # This prevents constant layout recalculation on each token
+        # Always force a minimal refresh to ensure content is visible
+        # This is critical for streaming to work properly
+        self.refresh(layout=False)
+        
+        # For Ollama responses, we need more aggressive refresh
+        # Check if this is likely an Ollama response by looking at the parent app
+        try:
+            app = self.app
+            if app and hasattr(app, 'selected_model'):
+                model = app.selected_model
+                if model and ('llama' in model.lower() or 'mistral' in model.lower() or 
+                             'gemma' in model.lower() or 'phi' in model.lower() or
+                             'ollama' in model.lower()):
+                    # This is likely an Ollama model, force a more thorough refresh
+                    # Without doing a full layout recalculation
+                    self.refresh(layout=True)
+                    
+                    # Force parent container to scroll to end
+                    try:
+                        parent = self.parent
+                        if parent and hasattr(parent, 'scroll_end'):
+                            parent.scroll_end(animate=False)
+                    except Exception:
+                        pass
+        except Exception:
+            # Ignore any errors in this detection logic
+            pass
         
     def _format_content(self, content: str) -> str:
-        """Format message content with timestamp"""
+        """Format message content with timestamp and handle markdown links"""
         timestamp = datetime.now().strftime("%H:%M")
-        return f"[dim]{timestamp}[/dim] {content}"
+        
+        # Fix markdown-style links that cause markup errors
+        # Convert [text](url) to a safe format for Textual markup
+        content = re.sub(
+            r'\[([^\]]+)\]\(([^)]+)\)',
+            lambda m: f"{m.group(1)} ({m.group(2)})",
+            content
+        )
+        
+        # Escape any other potential markup characters
+        content = content.replace("[", "\\[").replace("]", "\\]")
+        # But keep our timestamp markup
+        timestamp_markup = f"[dim]{timestamp}[/dim]"
+        
+        return f"{timestamp_markup} {content}"
 
 class InputWithFocus(Input):
     """Enhanced Input that better handles focus and maintains cursor position"""
@@ -179,7 +222,7 @@ class ChatInterface(Container):
         padding: 0 1;
         content-align: left top; /* Keep content anchored at top */
         box-sizing: border-box;
-        scrollbar-size: 1 1; /* Smaller scrollbars for more stability */
+        scrollbar-gutter: stable; /* Better than scrollbar-size which isn't valid */
     }
     
     #input-area {

app/ui/model_selector.py

@@ -243,12 +243,14 @@ class ModelSelector(Container):
                         
                     # Set the model if we found one
                     if first_model and len(first_model) >= 2:
-                        # Resolve the model ID before storing and sending
+                        # Get the original ID from the model option
                         original_id = first_model[1]
+                        # Resolve the model ID for internal use and messaging
                         resolved_id = resolve_model_id(original_id)
                         logger.info(f"on_select_changed (provider): Original ID '{original_id}' resolved to '{resolved_id}'")
                         self.selected_model = resolved_id
-                        model_select.value = resolved_id
+                        # Use the original ID for the select widget to avoid invalid value errors
+                        model_select.value = original_id
                         model_select.remove_class("hide")
                         self.query_one("#custom-model-input").add_class("hide")
                         self.post_message(self.ModelSelected(resolved_id))
@@ -310,24 +312,35 @@ class ModelSelector(Container):
     def set_selected_model(self, model_id: str) -> None:
         """Set the selected model, ensuring it's properly resolved"""
         # First resolve the model ID to ensure we're using the full ID
+        original_id = model_id
         resolved_id = resolve_model_id(model_id)
-        logger.info(f"set_selected_model: Original ID '{model_id}' resolved to '{resolved_id}'")
+        logger.info(f"set_selected_model: Original ID '{original_id}' resolved to '{resolved_id}'")
         
-        # Store the resolved ID
+        # Store the resolved ID internally
         self.selected_model = resolved_id
         
         # Update the UI based on whether this is a known model or custom
-        if resolved_id in CONFIG["available_models"]:
-            select = self.query_one("#model-select", Select)
+        # Check if the original ID is in the available options
+        model_select = self.query_one("#model-select", Select)
+        available_options = [opt[1] for opt in model_select.options]
+        
+        if original_id in available_options:
+            # Use the original ID for the select widget
+            custom_input = self.query_one("#custom-model-input")
+            model_select.value = original_id
+            model_select.remove_class("hide")
+            custom_input.add_class("hide")
+        elif resolved_id in available_options:
+            # If the resolved ID is in options, use that
             custom_input = self.query_one("#custom-model-input")
-            select.value = resolved_id
-            select.remove_class("hide")
+            model_select.value = resolved_id
+            model_select.remove_class("hide")
             custom_input.add_class("hide")
         else:
-            select = self.query_one("#model-select", Select)
+            # Use custom input for models not in the select options
             custom_input = self.query_one("#custom-model-input")
-            select.value = "custom"
-            select.add_class("hide")
+            model_select.value = "custom"
+            model_select.add_class("hide")
             custom_input.value = resolved_id
             custom_input.remove_class("hide")
 

app/utils.py

@@ -165,6 +165,9 @@ async def generate_streaming_response(
     
     debug_log(f"Messages validation complete: {len(messages)} total messages")
     
+    # Import time module within the worker function scope
+    import time
+    
     full_response = ""
     buffer = []
     last_update = time.time()
@@ -288,16 +291,35 @@ async def generate_streaming_response(
                     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:
+                    # Update UI with every chunk for short messages, or throttle for longer ones
+                    # This is especially important for short messages like "hi" that might otherwise not trigger updates
+                    if (current_time - last_update >= update_interval or 
+                        len(''.join(buffer)) > 10 or  # Much more aggressive buffer flush threshold
+                        len(full_response) < 20):     # Always update for very short responses
+                        
                         new_content = ''.join(buffer)
                         full_response += new_content
                         # Send content to UI
                         debug_log(f"Updating UI with content length: {len(full_response)}")
-                        await callback(full_response)
+                        try:
+                            await callback(full_response)
+                            debug_log("UI callback completed successfully")
+                        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)}")
                         buffer = []
                         last_update = current_time
                         
+                        # Force UI refresh after each update for Ollama responses
+                        if is_ollama:
+                            debug_log("Forcing UI refresh for Ollama response")
+                            try:
+                                # Ensure the app refreshes the UI
+                                if hasattr(app, 'refresh'):
+                                    app.refresh(layout=False)
+                            except Exception as refresh_err:
+                                debug_log(f"Error forcing UI refresh: {str(refresh_err)}")
+                        
                         # Small delay to let UI catch up
                         await asyncio.sleep(0.05)
         except asyncio.CancelledError:
@@ -313,7 +335,22 @@ async def generate_streaming_response(
             new_content = ''.join(buffer)
             full_response += new_content
             debug_log(f"Sending final content, total length: {len(full_response)}")
-            await callback(full_response)
+            try:
+                await callback(full_response)
+                debug_log("Final UI callback completed successfully")
+                
+                # Force final UI refresh for Ollama responses
+                if is_ollama:
+                    debug_log("Forcing final UI refresh for Ollama response")
+                    try:
+                        # Ensure the app refreshes the UI
+                        if hasattr(app, 'refresh'):
+                            app.refresh(layout=True)  # Use layout=True for final refresh
+                    except Exception as refresh_err:
+                        debug_log(f"Error forcing final UI refresh: {str(refresh_err)}")
+            except Exception as callback_err:
+                debug_log(f"Error in final UI callback: {str(callback_err)}")
+                logger.error(f"Error in final UI callback: {str(callback_err)}")
 
         debug_log(f"Streaming response completed successfully. Response length: {len(full_response)}")
         logger.info(f"Streaming response completed successfully. Response length: {len(full_response)}")
@@ -361,7 +398,7 @@ async def generate_streaming_response(
              return full_response
         return None # Indicate completion without full response (e.g., error before loop)
 
-def ensure_ollama_running() -> bool:
+async def ensure_ollama_running() -> bool:
     """
     Check if Ollama is running and try to start it if not.
     Returns True if Ollama is running after check/start attempt.
@@ -388,8 +425,7 @@ def ensure_ollama_running() -> bool:
             )
             
             # Wait a moment for it to start
-            import time
-            time.sleep(2)
+            await asyncio.sleep(2)  # Use asyncio.sleep instead of time.sleep
             
             # Check if process is still running
             if process.poll() is None:
@@ -440,7 +476,27 @@ def resolve_model_id(model_id_or_name: str) -> str:
          logger.warning("No available_models found in CONFIG to resolve against.")
          return model_id_or_name # Return original if no models to check
 
-    # 1. Check if the input is already a valid full ID (must contain a date suffix)
+    # Special case for Ollama models with version format (model:version)
+    if ":" in input_lower and not input_lower.startswith("claude-"):
+        logger.info(f"Input '{input_lower}' appears to be an Ollama model with version, returning as-is")
+        return model_id_or_name
+
+    # Handle special cases for common model formats
+    # 1. Handle Ollama models with dot notation (e.g., phi3.latest, llama3.1)
+    if "." in input_lower and not input_lower.startswith("claude-"):
+        # This is likely an Ollama model with dot notation
+        logger.info(f"Input '{input_lower}' appears to be an Ollama model with dot notation")
+        # Convert dots to colons for Ollama format if needed
+        if ":" not in input_lower:
+            parts = input_lower.split(".")
+            if len(parts) == 2:
+                base_model, version = parts
+                ollama_format = f"{base_model}:{version}"
+                logger.info(f"Converting '{input_lower}' to Ollama format: '{ollama_format}'")
+                return ollama_format
+        return model_id_or_name
+
+    # 2. Check if the input is already a valid full ID (must contain a date suffix)
     # Full Claude IDs should have format like "claude-3-opus-20240229" with a date suffix
     for full_id in available_models:
         if full_id.lower() == input_lower:
@@ -458,7 +514,7 @@ def resolve_model_id(model_id_or_name: str) -> str:
     best_match = None
     match_type = "None"
 
-    # 2. Iterate through available models for other matches
+    # 3. Iterate through available models for other matches
     for full_id, model_info in available_models.items():
         full_id_lower = full_id.lower()
         display_name = model_info.get("display_name", "")
@@ -466,12 +522,12 @@ def resolve_model_id(model_id_or_name: str) -> str:
 
         logger.debug(f"Comparing '{input_lower}' against '{full_id_lower}' (Display: '{display_name}')")
 
-        # 2a. Exact match on display name (case-insensitive)
+        # 3a. Exact match on display name (case-insensitive)
         if display_name_lower == input_lower:
             logger.info(f"Resolved '{model_id_or_name}' to '{full_id}' via exact display name match.")
             return full_id # Exact display name match is high confidence
 
-        # 2b. Check if input is a known short alias (handle common cases explicitly)
+        # 3b. Check if input is a known short alias (handle common cases explicitly)
         # Special case for Claude 3.7 Sonnet which seems to be causing issues
         if input_lower == "claude-3.7-sonnet":
             # Hardcoded resolution for this specific model
@@ -499,7 +555,7 @@ def resolve_model_id(model_id_or_name: str) -> str:
              # This is also high confidence
              return full_id
 
-        # 2c. Check if input is a prefix of the full ID (more general, lower confidence)
+        # 3c. Check if input is a prefix of the full ID (more general, lower confidence)
         if full_id_lower.startswith(input_lower):
             logger.debug(f"Potential prefix match: '{input_lower}' vs '{full_id_lower}'")
             # Don't return immediately, might find a better match (e.g., display name or alias)
@@ -508,7 +564,7 @@ def resolve_model_id(model_id_or_name: str) -> str:
                  match_type = "Prefix"
                  logger.debug(f"Setting best_match to '{full_id}' based on prefix.")
 
-        # 2d. Check derived short name from display name (less reliable, keep as lower priority)
+        # 3d. Check derived short name from display name (less reliable, keep as lower priority)
         # Normalize display name: lower, replace space and dot with hyphen
         derived_short_name = display_name_lower.replace(" ", "-").replace(".", "-")
         if derived_short_name == input_lower:
@@ -519,7 +575,7 @@ def resolve_model_id(model_id_or_name: str) -> str:
                   match_type = "Derived Short Name"
                   logger.debug(f"Updating best_match to '{full_id}' based on derived name.")
 
-    # 3. Return best match found or original input
+    # 4. Return best match found or original input
     if best_match:
         logger.info(f"Returning best match found for '{model_id_or_name}': '{best_match}' (Type: {match_type})")
         return best_match

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chat-console
-Version: 0.2.98
+Version: 0.3.0
 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.0.dist-info/RECORD

@@ -0,0 +1,24 @@
+app/__init__.py,sha256=r5cQDqO-BZ0zQldUI9laK2sHxNsMaRUP_KzKS5u3YCk,130
+app/config.py,sha256=KawltE7cK2bR9wbe1NSlepwWIjkiFw2bg3vbLmUnP38,7626
+app/database.py,sha256=nt8CVuDpy6zw8mOYqDcfUmNw611t7Ln7pz22M0b6-MI,9967
+app/main.py,sha256=y3sb3iSEQ-Dg6_Cr6EPtqCgYb7116Vr-RpmO2VYRuWk,73194
+app/models.py,sha256=4-y9Lytay2exWPFi0FDlVeRL3K2-I7E-jBqNzTfokqY,2644
+app/utils.py,sha256=TzY5I-A99FUIh-c1-OO7ZFea62Ex3XQCTUVXkXIoU04,30733
+app/api/__init__.py,sha256=A8UL84ldYlv8l7O-yKzraVFcfww86SgWfpl4p7R03-w,62
+app/api/anthropic.py,sha256=UpIP3CgAOUimdVyif41MhBOCAgOyFO8mX9SFQMKRAmc,12483
+app/api/base.py,sha256=bqBT4jne_W6Cvj_GoWWclV4Uk95fQvt-kkYqqZFJd8M,5769
+app/api/ollama.py,sha256=EBEEKXbgAYWEg_zF5PO_UKO5l_aoU3J_7tfCj9e-fqs,61699
+app/api/openai.py,sha256=JIRzCIcc5efvXhqWmSwISMcxTHDF4jYBCgAgnIivbpU,9018
+app/ui/__init__.py,sha256=RndfbQ1Tv47qdSiuQzvWP96lPS547SDaGE-BgOtiP_w,55
+app/ui/chat_interface.py,sha256=KbabnVVokC7sHjvAa5ddcLVPhuFE-oa68fKTprZbIJU,17696
+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=MfR4dbzjjf72FMWhyhSZXxx5CFdg5CY9cb9JlIkux5I,17695
+app/ui/search.py,sha256=b-m14kG3ovqW1-i0qDQ8KnAqFJbi5b1FLM9dOnbTyIs,9763
+app/ui/styles.py,sha256=04AhPuLrOd2yenfRySFRestPeuTPeMLzhmMB67NdGvw,5615
+chat_console-0.3.0.dist-info/licenses/LICENSE,sha256=srHZ3fvcAuZY1LHxE7P6XWju2njRCHyK6h_ftEbzxSE,1057
+chat_console-0.3.0.dist-info/METADATA,sha256=th7sGo5ZG71_QM7WC4zeyPAWbEhQzJkzVj_fu1ngWU8,2921
+chat_console-0.3.0.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+chat_console-0.3.0.dist-info/entry_points.txt,sha256=kkVdEc22U9PAi2AeruoKklfkng_a_aHAP6VRVwrAD7c,67
+chat_console-0.3.0.dist-info/top_level.txt,sha256=io9g7LCbfmTG1SFKgEOGXmCFB9uMP2H5lerm0HiHWQE,4
+chat_console-0.3.0.dist-info/RECORD,,

chat_console-0.2.98.dist-info/RECORD

@@ -1,24 +0,0 @@
-app/__init__.py,sha256=Mx4VF_U7IhLbSFel6dTS0LmWyZ6eBpnmhRlOw9sXLfE,131
-app/config.py,sha256=KawltE7cK2bR9wbe1NSlepwWIjkiFw2bg3vbLmUnP38,7626
-app/database.py,sha256=nt8CVuDpy6zw8mOYqDcfUmNw611t7Ln7pz22M0b6-MI,9967
-app/main.py,sha256=cvAdboaSLNB_eilgrPe0nuAa1bCtsSHnaSURFyJt5zk,69475
-app/models.py,sha256=4-y9Lytay2exWPFi0FDlVeRL3K2-I7E-jBqNzTfokqY,2644
-app/utils.py,sha256=y-U3vWGeJaaynQ1vNkht_DYLnRdzJDJh-u2bAinfj2Y,27428
-app/api/__init__.py,sha256=A8UL84ldYlv8l7O-yKzraVFcfww86SgWfpl4p7R03-w,62
-app/api/anthropic.py,sha256=jpvx_eKd5WqKc2KvpxjbInEfEmgw9o4YX1SXoUOaQ3M,12082
-app/api/base.py,sha256=PB6loU2_SbnKvYuA-KFqR86xUZg1sX-1IgfMl9HKhR8,5724
-app/api/ollama.py,sha256=B9jTeOmJpeAOg6UvvkcDt0xIe5PDkyUryMlhHBt3plA,60744
-app/api/openai.py,sha256=K_fVJ6YNFgUyE_sRAZMnUaCXuiXNm4iEqzTI0I1sdic,5842
-app/ui/__init__.py,sha256=RndfbQ1Tv47qdSiuQzvWP96lPS547SDaGE-BgOtiP_w,55
-app/ui/chat_interface.py,sha256=xU4yFcVS4etS5kx7cmnnUnF5p_nWDNmf68VKbYemJRg,15677
-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=eqwJamLddgt4fS0pJbCyCBe-_shqESm3gM8vJTOWDAs,16956
-app/ui/search.py,sha256=b-m14kG3ovqW1-i0qDQ8KnAqFJbi5b1FLM9dOnbTyIs,9763
-app/ui/styles.py,sha256=04AhPuLrOd2yenfRySFRestPeuTPeMLzhmMB67NdGvw,5615
-chat_console-0.2.98.dist-info/licenses/LICENSE,sha256=srHZ3fvcAuZY1LHxE7P6XWju2njRCHyK6h_ftEbzxSE,1057
-chat_console-0.2.98.dist-info/METADATA,sha256=qJwneYlSKgSj2HrjWs9Gj8sLYFiV5nULI31Xv_kmE68,2922
-chat_console-0.2.98.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-chat_console-0.2.98.dist-info/entry_points.txt,sha256=kkVdEc22U9PAi2AeruoKklfkng_a_aHAP6VRVwrAD7c,67
-chat_console-0.2.98.dist-info/top_level.txt,sha256=io9g7LCbfmTG1SFKgEOGXmCFB9uMP2H5lerm0HiHWQE,4
-chat_console-0.2.98.dist-info/RECORD,,