chat-console 0.3.9__py3-none-any.whl → 0.3.91__py3-none-any.whl

app/__init__.py

@@ -3,4 +3,4 @@ Chat CLI
 A command-line interface for chatting with various LLM providers like ChatGPT and Claude.
 """
 
-__version__ = "0.3.9"
+__version__ = "0.3.91"

app/api/ollama.py

@@ -11,6 +11,14 @@ from .base import BaseModelClient
 # Set up logging
 logger = logging.getLogger(__name__)
 
+# Custom exception for Ollama API errors
+class OllamaApiError(Exception):
+    """Exception raised for errors in the Ollama API."""
+    def __init__(self, message: str, status_code: Optional[int] = None):
+        self.message = message
+        self.status_code = status_code
+        super().__init__(self.message)
+
 class OllamaClient(BaseModelClient):
     def __init__(self):
         from ..config import OLLAMA_BASE_URL
@@ -280,13 +288,11 @@ class OllamaClient(BaseModelClient):
                     break
                     
             if not model_exists:
-                debug_log(f"Model '{model}' not found in available models")
-                # Instead of failing, yield a helpful error message
-                yield f"Model '{model}' not found. Available models include: {', '.join(available_model_names[:5])}"
+                error_msg = f"Model '{model}' not found in available models. Available models include: {', '.join(available_model_names[:5])}"
                 if len(available_model_names) > 5:
-                    yield f" and {len(available_model_names) - 5} more."
-                yield "\n\nPlease try a different model or check your spelling."
-                return
+                    error_msg += f" and {len(available_model_names) - 5} more."
+                logger.error(error_msg)
+                raise OllamaApiError(error_msg)
         except Exception as e:
             debug_log(f"Error checking model availability: {str(e)}")
             # Continue anyway, the main request will handle errors
@@ -329,10 +335,11 @@ class OllamaClient(BaseModelClient):
                                 if response.status == 404:
                                     error_text = await response.text()
                                     debug_log(f"404 error details: {error_text}")
-                                    # This is likely a model not found error
-                                    yield f"Error: Model '{model}' not found on the Ollama server."
-                                    yield "\nPlease check if the model name is correct or try pulling it first."
-                                    return
+                                    error_msg = f"Error: Model '{model}' not found on the Ollama server. Please check if the model name is correct or try pulling it first."
+                                    logger.error(error_msg)
+                                    # Instead of raising, yield the error message for user display
+                                    yield error_msg
+                                    return  # End the generation
                                     
                                 raise aiohttp.ClientError("Model not ready")
                     except (aiohttp.ClientError, asyncio.TimeoutError) as e:
@@ -367,9 +374,9 @@ class OllamaClient(BaseModelClient):
                                     error_text = await pull_response.text()
                                     debug_log(f"404 error details: {error_text}")
                                     # This is likely a model not found in registry
-                                    yield f"Error: Model '{model}' not found in the Ollama registry."
-                                    yield "\nPlease check if the model name is correct or try a different model."
-                                    return
+                                    error_msg = f"Error: Model '{model}' not found in the Ollama registry. Please check if the model name is correct or try a different model."
+                                    logger.error(error_msg)
+                                    raise OllamaApiError(error_msg, status_code=404)
                                     
                                 raise Exception("Failed to pull model")
                             logger.info("Model pulled successfully")

app/config.py

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

app/main.py

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

app/ui/chat_interface.py

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

app/utils.py

@@ -201,284 +201,589 @@ async def generate_conversation_title(message: str, model: str, client: Any) ->
     logger.error(f"Failed to generate title after multiple retries. Last error: {last_error}")
     return f"Conversation ({datetime.now().strftime('%Y-%m-%d %H:%M')})"
 
-# Worker function for streaming response generation
-async def generate_streaming_response(
+# Helper function for OpenAI streaming
+async def _generate_openai_stream(
     app: 'SimpleChatApp',
     messages: List[Dict],
     model: str,
     style: str,
     client: Any,
-    callback: Callable[[str], Awaitable[None]]
+    callback: Callable[[str], Awaitable[None]],
+    update_lock: asyncio.Lock
 ) -> Optional[str]:
-    """
-    Generate a streaming response from the model (as a Textual worker).
-    Refactored to be a coroutine, not an async generator.
-    """
+    """Generate streaming response using OpenAI provider."""
     try:
         from app.main import debug_log
     except ImportError:
         debug_log = lambda msg: None
-
-    logger.info(f"Starting streaming response with model: {model}")
-    debug_log(f"Starting streaming response with model: '{model}', client type: {type(client).__name__}")
-
-    # Validate messages
-    if not messages:
-        debug_log("Error: messages list is empty")
-        raise ValueError("Messages list cannot be empty")
-
-    # Ensure all messages have required fields
-    for i, msg in enumerate(messages):
+    
+    debug_log(f"Using OpenAI-specific streaming for model: {model}")
+    
+    # Initialize variables for response tracking
+    full_response = ""
+    buffer = []
+    last_update = time.time()
+    update_interval = 0.03  # Responsive updates for OpenAI
+    
+    try:
+        # Initialize stream generator
+        debug_log("Initializing OpenAI stream generator")
+        stream_generator = client.generate_stream(messages, model, style)
+        
+        # Process stream chunks
+        debug_log("Beginning to process OpenAI stream chunks")
+        async for chunk in stream_generator:
+            # Check for task cancellation
+            if asyncio.current_task().cancelled():
+                debug_log("Task cancellation detected during OpenAI chunk processing")
+                if hasattr(client, 'cancel_stream'):
+                    await client.cancel_stream()
+                raise asyncio.CancelledError()
+                
+            # Process chunk content
+            if chunk:
+                if not isinstance(chunk, str):
+                    try:
+                        chunk = str(chunk)
+                    except Exception:
+                        continue
+                        
+                buffer.append(chunk)
+                current_time = time.time()
+                
+                # Update UI with new content
+                if (current_time - last_update >= update_interval or
+                    len(''.join(buffer)) > 5 or
+                    len(full_response) < 50):
+                    
+                    new_content = ''.join(buffer)
+                    full_response += new_content
+                    
+                    try:
+                        async with update_lock:
+                            await callback(full_response)
+                            if hasattr(app, 'refresh'):
+                                app.refresh(layout=True)
+                    except Exception as callback_err:
+                        logger.error(f"Error in OpenAI UI callback: {str(callback_err)}")
+                        
+                    buffer = []
+                    last_update = current_time
+                    await asyncio.sleep(0.02)
+                    
+        # Process any remaining buffer content
+        if buffer:
+            new_content = ''.join(buffer)
+            full_response += new_content
+            
+            try:
+                async with update_lock:
+                    await callback(full_response)
+                    if hasattr(app, 'refresh'):
+                        app.refresh(layout=True)
+                        await asyncio.sleep(0.02)
+                        try:
+                            messages_container = app.query_one("#messages-container")
+                            if messages_container:
+                                messages_container.scroll_end(animate=False)
+                        except Exception:
+                            pass
+            except Exception as callback_err:
+                logger.error(f"Error in final OpenAI UI callback: {str(callback_err)}")
+                
+        # Final refresh to ensure everything is displayed correctly
         try:
-            debug_log(f"Message {i}: role={msg.get('role', 'missing')}, content_len={len(msg.get('content', ''))}")
-            if 'role' not in msg:
-                debug_log(f"Adding missing 'role' to message {i}")
-                msg['role'] = 'user'
-            if 'content' not in msg:
-                debug_log(f"Adding missing 'content' to message {i}")
-                msg['content'] = ''
-        except Exception as e:
-            debug_log(f"Error checking message {i}: {str(e)}")
-            messages[i] = {
-                'role': 'user',
-                'content': str(msg) if msg else ''
-            }
-            debug_log(f"Repaired message {i}")
+            await asyncio.sleep(0.05)
+            async with update_lock:
+                await callback(full_response)
+                if hasattr(app, 'refresh'):
+                    app.refresh(layout=True)
+        except Exception:
+            pass
+            
+        return full_response
+        
+    except asyncio.CancelledError:
+        logger.info(f"OpenAI streaming cancelled. Partial response length: {len(full_response)}")
+        if hasattr(client, 'cancel_stream'):
+            await client.cancel_stream()
+        return full_response
+        
+    except Exception as e:
+        logger.error(f"Error during OpenAI streaming: {str(e)}")
+        if hasattr(client, 'cancel_stream'):
+            await client.cancel_stream()
+        raise
 
+# Helper function for Anthropic streaming
+async def _generate_anthropic_stream(
+    app: 'SimpleChatApp',
+    messages: List[Dict],
+    model: str,
+    style: str,
+    client: Any,
+    callback: Callable[[str], Awaitable[None]],
+    update_lock: asyncio.Lock
+) -> Optional[str]:
+    """Generate streaming response using Anthropic provider."""
+    try:
+        from app.main import debug_log
+    except ImportError:
+        debug_log = lambda msg: None
+    
+    debug_log(f"Using Anthropic-specific streaming for model: {model}")
+    
     # Initialize variables for response tracking
     full_response = ""
     buffer = []
     last_update = time.time()
-    update_interval = 0.05  # Reduced interval for more frequent updates
-
+    update_interval = 0.03  # Responsive updates for Anthropic
+    
     try:
-        # Validate client
-        if client is None:
-            debug_log("Error: client is None, cannot proceed with streaming")
-            raise ValueError("Model client is None, cannot proceed with streaming")
-
-        if not hasattr(client, 'generate_stream'):
-            debug_log(f"Error: client {type(client).__name__} does not have generate_stream method")
-            raise ValueError(f"Client {type(client).__name__} does not support streaming")
-
-        # Determine client type
-        is_ollama = 'ollama' in str(type(client)).lower()
-        is_openai = 'openai' in str(type(client)).lower()
-        is_anthropic = 'anthropic' in str(type(client)).lower()
+        # Initialize stream generator
+        debug_log("Initializing Anthropic stream generator")
+        stream_generator = client.generate_stream(messages, model, style)
+        
+        # Process stream chunks
+        debug_log("Beginning to process Anthropic stream chunks")
+        async for chunk in stream_generator:
+            # Check for task cancellation
+            if asyncio.current_task().cancelled():
+                debug_log("Task cancellation detected during Anthropic chunk processing")
+                if hasattr(client, 'cancel_stream'):
+                    await client.cancel_stream()
+                raise asyncio.CancelledError()
+                
+            # Process chunk content
+            if chunk:
+                if not isinstance(chunk, str):
+                    try:
+                        chunk = str(chunk)
+                    except Exception:
+                        continue
+                        
+                buffer.append(chunk)
+                current_time = time.time()
+                
+                # Update UI with new content
+                if (current_time - last_update >= update_interval or
+                    len(''.join(buffer)) > 5 or
+                    len(full_response) < 50):
+                    
+                    new_content = ''.join(buffer)
+                    full_response += new_content
+                    
+                    try:
+                        async with update_lock:
+                            await callback(full_response)
+                            if hasattr(app, 'refresh'):
+                                app.refresh(layout=True)
+                    except Exception as callback_err:
+                        logger.error(f"Error in Anthropic UI callback: {str(callback_err)}")
+                        
+                    buffer = []
+                    last_update = current_time
+                    await asyncio.sleep(0.02)
+                    
+        # Process any remaining buffer content
+        if buffer:
+            new_content = ''.join(buffer)
+            full_response += new_content
+            
+            try:
+                async with update_lock:
+                    await callback(full_response)
+                    if hasattr(app, 'refresh'):
+                        app.refresh(layout=True)
+                        await asyncio.sleep(0.02)
+                        try:
+                            messages_container = app.query_one("#messages-container")
+                            if messages_container:
+                                messages_container.scroll_end(animate=False)
+                        except Exception:
+                            pass
+            except Exception as callback_err:
+                logger.error(f"Error in final Anthropic UI callback: {str(callback_err)}")
+                
+        # Final refresh to ensure everything is displayed correctly
+        try:
+            await asyncio.sleep(0.05)
+            async with update_lock:
+                await callback(full_response)
+                if hasattr(app, 'refresh'):
+                    app.refresh(layout=True)
+        except Exception:
+            pass
+            
+        return full_response
+        
+    except asyncio.CancelledError:
+        logger.info(f"Anthropic streaming cancelled. Partial response length: {len(full_response)}")
+        if hasattr(client, 'cancel_stream'):
+            await client.cancel_stream()
+        return full_response
         
-        debug_log(f"Client types - Ollama: {is_ollama}, OpenAI: {is_openai}, Anthropic: {is_anthropic}")
+    except Exception as e:
+        logger.error(f"Error during Anthropic streaming: {str(e)}")
+        if hasattr(client, 'cancel_stream'):
+            await client.cancel_stream()
+        raise
 
-        # Only show loading indicator for Ollama (which may need to load models)
-        # This prevents Ollama-specific UI elements from showing when using other providers
-        if is_ollama and hasattr(app, 'query_one'):
+# Helper function for Ollama streaming
+async def _generate_ollama_stream(
+    app: 'SimpleChatApp',
+    messages: List[Dict],
+    model: str,
+    style: str,
+    client: Any,
+    callback: Callable[[str], Awaitable[None]],
+    update_lock: asyncio.Lock
+) -> Optional[str]:
+    """Generate streaming response using Ollama provider."""
+    try:
+        from app.main import debug_log
+    except ImportError:
+        debug_log = lambda msg: None
+    
+    debug_log(f"Using Ollama-specific streaming for model: {model}")
+    
+    # Initialize variables for response tracking
+    full_response = ""
+    buffer = []
+    last_update = time.time()
+    update_interval = 0.03  # Responsive updates for Ollama
+    
+    try:
+        # Show loading indicator for Ollama (which may need to load models)
+        if hasattr(app, 'query_one'):
             try:
                 debug_log("Showing initial model loading indicator for Ollama")
-                logger.info("Showing initial model loading indicator for Ollama")
                 loading = app.query_one("#loading-indicator")
                 loading.add_class("model-loading")
                 loading.update("⚙️ Loading Ollama model...")
             except Exception as e:
                 debug_log(f"Error setting initial Ollama loading state: {str(e)}")
-                logger.error(f"Error setting initial Ollama loading state: {str(e)}")
-
-        debug_log(f"Starting stream generation with messages length: {len(messages)}")
-        logger.info(f"Starting stream generation for model: {model}")
-
+        
         # Initialize stream generator
-        try:
-            debug_log("Calling client.generate_stream()")
-            stream_generator = client.generate_stream(messages, model, style)
-            debug_log("Successfully obtained stream generator")
-        except Exception as stream_init_error:
-            debug_log(f"Error initializing stream generator: {str(stream_init_error)}")
-            logger.error(f"Error initializing stream generator: {str(stream_init_error)}")
-            raise
-
-        # Update UI if model is ready (Ollama specific)
-        # Only check is_loading_model for Ollama clients to prevent errors with other providers
-        if is_ollama and hasattr(client, 'is_loading_model') and not client.is_loading_model() and hasattr(app, 'query_one'):
+        debug_log("Initializing Ollama stream generator")
+        stream_generator = client.generate_stream(messages, model, style)
+        
+        # Update UI if model is ready
+        if hasattr(client, 'is_loading_model') and not client.is_loading_model() and hasattr(app, 'query_one'):
             try:
                 debug_log("Ollama model is ready for generation, updating UI")
-                logger.info("Ollama model is ready for generation, updating UI")
                 loading = app.query_one("#loading-indicator")
                 loading.remove_class("model-loading")
                 loading.update("▪▪▪ Generating response...")
             except Exception as e:
-                debug_log(f"Error updating UI after stream init: {str(e)}")
-                logger.error(f"Error updating UI after stream init: {str(e)}")
-
+                debug_log(f"Error updating UI after Ollama stream init: {str(e)}")
+        
         # Process stream chunks
-        debug_log("Beginning to process stream chunks")
-        try:
-            async for chunk in stream_generator:
-                # Check for task cancellation
-                if asyncio.current_task().cancelled():
-                    debug_log("Task cancellation detected during chunk processing")
-                    logger.info("Task cancellation detected during chunk processing")
-                    if hasattr(client, 'cancel_stream'):
-                        debug_log("Calling client.cancel_stream() due to task cancellation")
-                        await client.cancel_stream()
-                    raise asyncio.CancelledError()
-
-                # Handle Ollama model loading state changes - only for Ollama clients
-                if is_ollama and hasattr(client, 'is_loading_model'):
-                    try:
-                        model_loading = client.is_loading_model()
-                        debug_log(f"Ollama model loading state: {model_loading}")
-                        if hasattr(app, 'query_one'):
-                            try:
-                                loading = app.query_one("#loading-indicator")
-                                if model_loading and hasattr(loading, 'has_class') and not loading.has_class("model-loading"):
-                                    debug_log("Ollama model loading started during streaming")
-                                    logger.info("Ollama model loading started during streaming")
-                                    loading.add_class("model-loading")
-                                    loading.update("⚙️ Loading Ollama model...")
-                                elif not model_loading and hasattr(loading, 'has_class') and loading.has_class("model-loading"):
-                                    debug_log("Ollama model loading finished during streaming")
-                                    logger.info("Ollama model loading finished during streaming")
-                                    loading.remove_class("model-loading")
-                                    loading.update("▪▪▪ Generating response...")
-                            except Exception as ui_e:
-                                debug_log(f"Error updating UI elements: {str(ui_e)}")
-                                logger.error(f"Error updating UI elements: {str(ui_e)}")
-                    except Exception as e:
-                        debug_log(f"Error checking Ollama model loading state: {str(e)}")
-                        logger.error(f"Error checking Ollama model loading state: {str(e)}")
-
-                # Process chunk content
-                if chunk:
-                    if not isinstance(chunk, str):
-                        debug_log(f"WARNING: Received non-string chunk of type: {type(chunk).__name__}")
+        debug_log("Beginning to process Ollama stream chunks")
+        async for chunk in stream_generator:
+            # Check for task cancellation
+            if asyncio.current_task().cancelled():
+                debug_log("Task cancellation detected during Ollama chunk processing")
+                if hasattr(client, 'cancel_stream'):
+                    await client.cancel_stream()
+                raise asyncio.CancelledError()
+                
+            # Handle Ollama model loading state changes
+            if hasattr(client, 'is_loading_model'):
+                try:
+                    model_loading = client.is_loading_model()
+                    if hasattr(app, 'query_one'):
                         try:
-                            chunk = str(chunk)
-                            debug_log(f"Successfully converted chunk to string, length: {len(chunk)}")
-                        except Exception as e:
-                            debug_log(f"Error converting chunk to string: {str(e)}")
-                            continue
-
-                    debug_log(f"Received chunk of length: {len(chunk)}")
-                    buffer.append(chunk)
-                    current_time = time.time()
-
-                    # Update UI with new content
-                    # Always update immediately for the first few chunks for better responsiveness
-                    if (current_time - last_update >= update_interval or
-                        len(''.join(buffer)) > 5 or  # Reduced buffer size threshold
-                        len(full_response) < 50):    # More aggressive updates for early content
-
-                        new_content = ''.join(buffer)
-                        full_response += new_content
-                        debug_log(f"Updating UI with content length: {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}'")
+                            loading = app.query_one("#loading-indicator")
+                            if model_loading and hasattr(loading, 'has_class') and not loading.has_class("model-loading"):
+                                debug_log("Ollama model loading started during streaming")
+                                loading.add_class("model-loading")
+                                loading.update("⚙️ Loading Ollama model...")
+                            elif not model_loading and hasattr(loading, 'has_class') and loading.has_class("model-loading"):
+                                debug_log("Ollama model loading finished during streaming")
+                                loading.remove_class("model-loading")
+                                loading.update("▪▪▪ Generating response...")
+                        except Exception:
+                            pass
+                except Exception:
+                    pass
+                
+            # Process chunk content
+            if chunk:
+                if not isinstance(chunk, str):
+                    try:
+                        chunk = str(chunk)
+                    except Exception:
+                        continue
                         
-                        try:
-                            # Call the UI callback with the full response so far
-                            debug_log("Calling UI callback with content")
+                buffer.append(chunk)
+                current_time = time.time()
+                
+                # Update UI with new content
+                if (current_time - last_update >= update_interval or
+                    len(''.join(buffer)) > 5 or
+                    len(full_response) < 50):
+                    
+                    new_content = ''.join(buffer)
+                    full_response += new_content
+                    
+                    try:
+                        async with update_lock:
                             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)}")
-                            print(f"STREAM ERROR: Error updating UI: {str(callback_err)}")
-                            
-                        buffer = []
-                        last_update = current_time
+                                app.refresh(layout=True)
+                    except Exception as callback_err:
+                        logger.error(f"Error in Ollama UI callback: {str(callback_err)}")
                         
-                        # Shorter sleep between updates for more responsive streaming
-                        await asyncio.sleep(0.02)
-        except asyncio.CancelledError:
-            debug_log("CancelledError in stream processing")
-            raise
-        except Exception as chunk_error:
-            debug_log(f"Error processing stream chunks: {str(chunk_error)}")
-            logger.error(f"Error processing stream chunks: {str(chunk_error)}")
-            raise
-
+                    buffer = []
+                    last_update = current_time
+                    await asyncio.sleep(0.02)
+                    
+        # Process any remaining buffer content
         if buffer:
             new_content = ''.join(buffer)
             full_response += new_content
-            debug_log(f"Sending final content, total length: {len(full_response)}")
+            
             try:
-                await callback(full_response)
-                debug_log("Final UI callback completed successfully")
-
-                debug_log("Forcing final UI refresh sequence for all models")
-                try:
+                async with update_lock:
+                    await callback(full_response)
                     if hasattr(app, 'refresh'):
-                        app.refresh(layout=False)
+                        app.refresh(layout=True)
                         await asyncio.sleep(0.02)
                         try:
                             messages_container = app.query_one("#messages-container")
-                            if messages_container and hasattr(messages_container, 'scroll_end'):
+                            if messages_container:
                                 messages_container.scroll_end(animate=False)
                         except Exception:
                             pass
+            except Exception as callback_err:
+                logger.error(f"Error in final Ollama UI callback: {str(callback_err)}")
+                
+        # Final refresh to ensure everything is displayed correctly
+        try:
+            await asyncio.sleep(0.05)
+            async with update_lock:
+                await callback(full_response)
+                if hasattr(app, 'refresh'):
+                    app.refresh(layout=True)
+        except Exception:
+            pass
+            
+        return full_response
+        
+    except asyncio.CancelledError:
+        logger.info(f"Ollama streaming cancelled. Partial response length: {len(full_response)}")
+        if hasattr(client, 'cancel_stream'):
+            await client.cancel_stream()
+        return full_response
+        
+    except Exception as e:
+        logger.error(f"Error during Ollama streaming: {str(e)}")
+        if hasattr(client, 'cancel_stream'):
+            await client.cancel_stream()
+        raise
+
+# Generic fallback streaming implementation
+async def _generate_generic_stream(
+    app: 'SimpleChatApp',
+    messages: List[Dict],
+    model: str,
+    style: str,
+    client: Any,
+    callback: Callable[[str], Awaitable[None]],
+    update_lock: asyncio.Lock
+) -> Optional[str]:
+    """Generic fallback implementation for streaming responses."""
+    try:
+        from app.main import debug_log
+    except ImportError:
+        debug_log = lambda msg: None
+    
+    debug_log(f"Using generic streaming for model: {model}, client type: {type(client).__name__}")
+    
+    # Initialize variables for response tracking
+    full_response = ""
+    buffer = []
+    last_update = time.time()
+    update_interval = 0.03  # Responsive updates
+    
+    try:
+        # Initialize stream generator
+        debug_log("Initializing generic stream generator")
+        stream_generator = client.generate_stream(messages, model, style)
+        
+        # Process stream chunks
+        debug_log("Beginning to process generic stream chunks")
+        async for chunk in stream_generator:
+            # Check for task cancellation
+            if asyncio.current_task().cancelled():
+                debug_log("Task cancellation detected during generic chunk processing")
+                if hasattr(client, 'cancel_stream'):
+                    await client.cancel_stream()
+                raise asyncio.CancelledError()
+                
+            # Process chunk content
+            if chunk:
+                if not isinstance(chunk, str):
+                    try:
+                        chunk = str(chunk)
+                    except Exception:
+                        continue
+                        
+                buffer.append(chunk)
+                current_time = time.time()
+                
+                # Update UI with new content
+                if (current_time - last_update >= update_interval or
+                    len(''.join(buffer)) > 5 or
+                    len(full_response) < 50):
+                    
+                    new_content = ''.join(buffer)
+                    full_response += new_content
+                    
+                    try:
+                        async with update_lock:
+                            await callback(full_response)
+                            if hasattr(app, 'refresh'):
+                                app.refresh(layout=True)
+                    except Exception as callback_err:
+                        logger.error(f"Error in generic UI callback: {str(callback_err)}")
+                        
+                    buffer = []
+                    last_update = current_time
+                    await asyncio.sleep(0.02)
+                    
+        # Process any remaining buffer content
+        if buffer:
+            new_content = ''.join(buffer)
+            full_response += new_content
+            
+            try:
+                async with update_lock:
+                    await callback(full_response)
+                    if hasattr(app, 'refresh'):
                         app.refresh(layout=True)
                         await asyncio.sleep(0.02)
                         try:
                             messages_container = app.query_one("#messages-container")
-                            if messages_container and hasattr(messages_container, 'scroll_end'):
+                            if messages_container:
                                 messages_container.scroll_end(animate=False)
                         except Exception:
                             pass
-                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)}")
-
+                logger.error(f"Error in final generic UI callback: {str(callback_err)}")
+                
+        # Final refresh to ensure everything is displayed correctly
         try:
             await asyncio.sleep(0.05)
-            debug_log("Sending one final callback to ensure UI refresh")
-            await callback(full_response)
-            if hasattr(app, 'refresh'):
-                app.refresh(layout=True)
-        except Exception as final_err:
-            debug_log(f"Error in final extra callback: {str(final_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)}")
+            async with update_lock:
+                await callback(full_response)
+                if hasattr(app, 'refresh'):
+                    app.refresh(layout=True)
+        except Exception:
+            pass
+            
         return full_response
-
+        
     except asyncio.CancelledError:
-        debug_log(f"Streaming response task cancelled. Partial response length: {len(full_response)}")
-        logger.info(f"Streaming response task cancelled. Partial response length: {len(full_response)}")
+        logger.info(f"Generic streaming cancelled. Partial response length: {len(full_response)}")
         if hasattr(client, 'cancel_stream'):
-            debug_log("Calling client.cancel_stream() after cancellation")
-            try:
-                await client.cancel_stream()
-                debug_log("Successfully cancelled client stream")
-            except Exception as cancel_err:
-                debug_log(f"Error cancelling client stream: {str(cancel_err)}")
+            await client.cancel_stream()
         return full_response
-
+        
     except Exception as e:
-        debug_log(f"Error during streaming response: {str(e)}")
-        logger.error(f"Error during streaming response: {str(e)}")
+        logger.error(f"Error during generic streaming: {str(e)}")
         if hasattr(client, 'cancel_stream'):
-            debug_log("Attempting to cancel client stream after error")
-            try:
-                await client.cancel_stream()
-                debug_log("Successfully cancelled client stream after error")
-            except Exception as cancel_err:
-                debug_log(f"Error cancelling client stream after error: {str(cancel_err)}")
+            await client.cancel_stream()
         raise
 
-    finally:
-        debug_log("generate_streaming_response worker finished or errored.")
-        if 'full_response' in locals():
-            return full_response
-        return None
+# Worker function for streaming response generation
+async def generate_streaming_response(
+    app: 'SimpleChatApp',
+    messages: List[Dict],
+    model: str,
+    style: str,
+    client: Any,
+    callback: Callable[[str], Awaitable[None]]
+) -> Optional[str]:
+    """
+    Generate a streaming response from the model (as a Textual worker).
+    Refactored to be a coroutine, not an async generator.
+    """
+    try:
+        from app.main import debug_log
+    except ImportError:
+        debug_log = lambda msg: None
+
+    logger.info(f"Starting streaming response with model: {model}")
+    debug_log(f"Starting streaming response with model: '{model}', client type: {type(client).__name__}")
+
+    # Validate messages
+    if not messages:
+        debug_log("Error: messages list is empty")
+        raise ValueError("Messages list cannot be empty")
+
+    # Ensure all messages have required fields
+    for i, msg in enumerate(messages):
+        try:
+            debug_log(f"Message {i}: role={msg.get('role', 'missing')}, content_len={len(msg.get('content', ''))}")
+            if 'role' not in msg:
+                debug_log(f"Adding missing 'role' to message {i}")
+                msg['role'] = 'user'
+            if 'content' not in msg:
+                debug_log(f"Adding missing 'content' to message {i}")
+                msg['content'] = ''
+        except Exception as e:
+            debug_log(f"Error checking message {i}: {str(e)}")
+            messages[i] = {
+                'role': 'user',
+                'content': str(msg) if msg else ''
+            }
+            debug_log(f"Repaired message {i}")
+            
+    # Create a lock for synchronizing UI updates
+    update_lock = asyncio.Lock()
+    
+    # Validate client
+    if client is None:
+        debug_log("Error: client is None, cannot proceed with streaming")
+        raise ValueError("Model client is None, cannot proceed with streaming")
+
+    if not hasattr(client, 'generate_stream'):
+        debug_log(f"Error: client {type(client).__name__} does not have generate_stream method")
+        raise ValueError(f"Client {type(client).__name__} does not support streaming")
+
+    # Explicitly check provider type first
+    is_ollama = 'ollama' in str(type(client)).lower()
+    is_openai = 'openai' in str(type(client)).lower()
+    is_anthropic = 'anthropic' in str(type(client)).lower()
+    
+    debug_log(f"Client types - Ollama: {is_ollama}, OpenAI: {is_openai}, Anthropic: {is_anthropic}")
+    
+    # Use separate implementations for each provider
+    try:
+        if is_openai:
+            debug_log("Using OpenAI-specific streaming implementation")
+            return await _generate_openai_stream(app, messages, model, style, client, callback, update_lock)
+        elif is_anthropic:
+            debug_log("Using Anthropic-specific streaming implementation")
+            return await _generate_anthropic_stream(app, messages, model, style, client, callback, update_lock)
+        elif is_ollama:
+            debug_log("Using Ollama-specific streaming implementation")
+            return await _generate_ollama_stream(app, messages, model, style, client, callback, update_lock)
+        else:
+            # Generic fallback
+            debug_log("Using generic streaming implementation")
+            return await _generate_generic_stream(app, messages, model, style, client, callback, update_lock)
+    except asyncio.CancelledError:
+        debug_log("Task cancellation detected in main streaming function")
+        if hasattr(client, 'cancel_stream'):
+            await client.cancel_stream()
+        raise
+    except Exception as e:
+        debug_log(f"Error in streaming implementation: {str(e)}")
+        logger.error(f"Error in streaming implementation: {str(e)}")
+        raise
 
 async def ensure_ollama_running() -> bool:
     """
@@ -555,6 +860,22 @@ def resolve_model_id(model_id_or_name: str) -> str:
     input_lower = model_id_or_name.lower().strip()
     logger.info(f"Attempting to resolve model identifier: '{input_lower}'")
     
+    # Add special case handling for common OpenAI models
+    openai_model_aliases = {
+        "04-mini": "gpt-4-mini",  # Fix "04-mini" typo to "gpt-4-mini"
+        "04": "gpt-4",
+        "04-vision": "gpt-4-vision",
+        "04-turbo": "gpt-4-turbo",
+        "035": "gpt-3.5-turbo",
+        "35-turbo": "gpt-3.5-turbo",
+        "35": "gpt-3.5-turbo"
+    }
+    
+    if input_lower in openai_model_aliases:
+        resolved = openai_model_aliases[input_lower]
+        logger.info(f"Resolved '{input_lower}' to '{resolved}' via OpenAI model alias")
+        return resolved
+    
     # Special case handling for common typos and model name variations
     typo_corrections = {
         "o4-mini": "04-mini",

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

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

chat_console-0.3.91.dist-info/RECORD

@@ -0,0 +1,24 @@
+app/__init__.py,sha256=1Z7Qdm9b_jcT0nisliyzs6res69PiL36mZcYaHwpzvY,131
+app/config.py,sha256=xeRGXcKbNvAdQGkaJJBipM4yHZJTM1y4ZFoW764APOU,7661
+app/database.py,sha256=nt8CVuDpy6zw8mOYqDcfUmNw611t7Ln7pz22M0b6-MI,9967
+app/main.py,sha256=fYwnYiK4FEpTCBP8QByUBaXyAPWR1h2dG7aLdtcnkzs,75602
+app/models.py,sha256=4-y9Lytay2exWPFi0FDlVeRL3K2-I7E-jBqNzTfokqY,2644
+app/utils.py,sha256=DsK_Zid9HG9v6cX1y8-4uS_86AgMRTrGFjVn-fctbDM,44949
+app/api/__init__.py,sha256=A8UL84ldYlv8l7O-yKzraVFcfww86SgWfpl4p7R03-w,62
+app/api/anthropic.py,sha256=uInwNvGLJ_iPUs4BjdwaqXTU6NfmK1SzX7498Pt44fI,10667
+app/api/base.py,sha256=Oqu674v0NkrJY91tvxGd6YWgyi6XrFvi03quzWGswg8,7425
+app/api/ollama.py,sha256=zQcrs3COoS4wu9amp5oSmIsBNYK_ntilcGIPOe4wafI,64649
+app/api/openai.py,sha256=hLPr955tUx_2vwRuLP8Zrl3vu7kQZgUETi4cJuaYnFE,10810
+app/ui/__init__.py,sha256=RndfbQ1Tv47qdSiuQzvWP96lPS547SDaGE-BgOtiP_w,55
+app/ui/chat_interface.py,sha256=prJNmigK7yD-7hb-61mgG2JXcJeDgADySYSElGEUmTg,18683
+app/ui/chat_list.py,sha256=WQTYVNSSXlx_gQal3YqILZZKL9UiTjmNMIDX2I9pAMM,11205
+app/ui/model_browser.py,sha256=pdblLVkdyVF0_Bo02bqbErGAtieyH-y6IfhMOPEqIso,71124
+app/ui/model_selector.py,sha256=ue3rbZfjVsjli-rJN5mfSqq23Ci7NshmTb4xWS-uG5k,18685
+app/ui/search.py,sha256=b-m14kG3ovqW1-i0qDQ8KnAqFJbi5b1FLM9dOnbTyIs,9763
+app/ui/styles.py,sha256=04AhPuLrOd2yenfRySFRestPeuTPeMLzhmMB67NdGvw,5615
+chat_console-0.3.91.dist-info/licenses/LICENSE,sha256=srHZ3fvcAuZY1LHxE7P6XWju2njRCHyK6h_ftEbzxSE,1057
+chat_console-0.3.91.dist-info/METADATA,sha256=7mGtC-c-bML6p0ku5YaFSpYO0rZGbF7NZfhuUUB96u0,2922
+chat_console-0.3.91.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
+chat_console-0.3.91.dist-info/entry_points.txt,sha256=kkVdEc22U9PAi2AeruoKklfkng_a_aHAP6VRVwrAD7c,67
+chat_console-0.3.91.dist-info/top_level.txt,sha256=io9g7LCbfmTG1SFKgEOGXmCFB9uMP2H5lerm0HiHWQE,4
+chat_console-0.3.91.dist-info/RECORD,,

chat_console-0.3.9.dist-info/RECORD

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