chat-console 0.2.99__py3-none-any.whl → 0.3.4__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.99"
+__version__ = "0.3.4"

app/api/anthropic.py

@@ -144,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

@@ -120,8 +120,8 @@ class BaseModelClient(ABC):
         if provider == "ollama":
             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

@@ -369,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:
@@ -378,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,4 +1,5 @@
 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
@@ -84,47 +85,103 @@ 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]]:
-        """Get list of available OpenAI models"""
-        return [
-            {"id": "gpt-3.5-turbo", "name": "GPT-3.5 Turbo"},
-            {"id": "gpt-4", "name": "GPT-4"},
-            {"id": "gpt-4-turbo", "name": "GPT-4 Turbo"}
-        ]
+    async def get_available_models(self) -> List[Dict[str, Any]]:
+        """Fetch list of available OpenAI models from the /models endpoint"""
+        try:
+            models_response = await self.client.models.list()
+            # Each model has an 'id' and possibly other metadata
+            models = []
+            for model in models_response.data:
+                # Use 'id' as both id and name for now; can enhance with more info if needed
+                models.append({"id": model.id, "name": model.id})
+            return models
+        except Exception as e:
+            # Fallback to a static list if API call fails
+            return [
+                {"id": "gpt-3.5-turbo", "name": "gpt-3.5-turbo"},
+                {"id": "gpt-4", "name": "gpt-4"},
+                {"id": "gpt-4-turbo", "name": "gpt-4-turbo"}
+            ]