chat-console 0.2.9__py3-none-any.whl → 0.2.99__py3-none-any.whl

app/api/openai.py

@@ -5,7 +5,14 @@ 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"""
@@ -55,21 +62,63 @@ class OpenAIClient(BaseModelClient):
                             temperature: float = 0.7, 
                             max_tokens: Optional[int] = None) -> AsyncGenerator[str, None]:
         """Generate a streaming text completion using OpenAI"""
+        try:
+            from app.main import debug_log  # Import debug logging if available
+            debug_log(f"OpenAI: starting streaming generation with model: {model}")
+        except ImportError:
+            # If debug_log not available, create a no-op function
+            debug_log = lambda msg: None
+            
         processed_messages = self._prepare_messages(messages, style)
         
         try:
+            debug_log(f"OpenAI: preparing {len(processed_messages)} messages for stream")
+            
+            # Safely prepare messages
+            try:
+                api_messages = []
+                for m in processed_messages:
+                    if isinstance(m, dict) and "role" in m and "content" in m:
+                        api_messages.append({"role": m["role"], "content": m["content"]})
+                    else:
+                        debug_log(f"OpenAI: skipping invalid message: {m}")
+                
+                debug_log(f"OpenAI: prepared {len(api_messages)} valid messages")
+            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=[{"role": m["role"], "content": m["content"]} for m in processed_messages],
+                messages=api_messages,
                 temperature=temperature,
                 max_tokens=max_tokens,
                 stream=True,
             )
             
+            debug_log("OpenAI: stream created successfully, processing chunks")
             async for chunk in stream:
-                if chunk.choices and chunk.choices[0].delta.content is not None:
-                    yield chunk.choices[0].delta.content
+                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
+                    
         except Exception as e:
+            debug_log(f"OpenAI: error in generate_stream: {str(e)}")
             raise Exception(f"OpenAI streaming error: {str(e)}")
     
     def get_available_models(self) -> List[Dict[str, Any]]:

app/config.py

@@ -52,24 +52,30 @@ DEFAULT_CONFIG = {
             "max_tokens": 8192,
             "display_name": "GPT-4"
         },
-        "claude-3-opus": {
+        # Use the corrected keys from anthropic.py
+        "claude-3-opus-20240229": {
             "provider": "anthropic",
-            "max_tokens": 4096,
+            "max_tokens": 4096, # Note: Max tokens might differ per model version
             "display_name": "Claude 3 Opus"
         },
-        "claude-3-sonnet": {
+        "claude-3-sonnet-20240229": {
             "provider": "anthropic",
-            "max_tokens": 4096,
+            "max_tokens": 4096, # Note: Max tokens might differ per model version
             "display_name": "Claude 3 Sonnet"
         },
-        "claude-3-haiku": {
+        "claude-3-haiku-20240307": {
             "provider": "anthropic",
             "max_tokens": 4096,
             "display_name": "Claude 3 Haiku"
         },
-        "claude-3.7-sonnet": {
+        "claude-3-5-sonnet-20240620": {
             "provider": "anthropic",
-            "max_tokens": 4096,
+            "max_tokens": 4096, # Note: Max tokens might differ per model version
+            "display_name": "Claude 3.5 Sonnet" # Corrected display name
+        },
+        "claude-3-7-sonnet-20250219": {
+            "provider": "anthropic",
+            "max_tokens": 4096, # Note: Max tokens might differ per model version
             "display_name": "Claude 3.7 Sonnet"
         },
         "llama2": {
@@ -166,3 +172,43 @@ def save_config(config):
 
 # Current configuration
 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."""
+    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
+
+        except Exception as e:
+            print(f"Error updating Anthropic models in config: {e}") # Add print statement
+            # Keep existing config if update fails
+
+    return config
+
+# Update the global CONFIG after loading it
+CONFIG = update_anthropic_models(CONFIG)
+# Optionally save the updated config back immediately (or rely on later saves)
+# save_config(CONFIG) # Uncomment if you want to persist the fetched models immediately