Update multi_llm_provider.py

multi_llm_provider.py

@@ -24,7 +24,14 @@ class AIProviderManager:
         if ANTHROPIC_API_KEY:
             try:
                 self.providers["claude"] = anthropic.Anthropic(api_key=ANTHROPIC_API_KEY)
-                st.sidebar.success("🟢 Claude AI connected")
+                
+                # Test connection by listing models
+                try:
+                    models = self.providers["claude"].models.list()
+                    model_list = [model.id for model in models.data]
+                    st.sidebar.success(f"🟢 Claude AI connected - Available models: {', '.join(model_list[:3])}")
+                except Exception as e:
+                    st.sidebar.warning(f"🟡 Claude AI connected but couldn't list models: {str(e)}")
             except Exception as e:
                 st.sidebar.error(f"🔴 Error initializing Claude: {str(e)}")
         
@@ -34,7 +41,14 @@ class AIProviderManager:
                 import openai
                 openai.api_key = OPENAI_API_KEY
                 self.providers["openai"] = True
-                st.sidebar.success("🟢 OpenAI connected")
+                
+                # Test connection by listing models
+                try:
+                    client = openai.OpenAI(api_key=OPENAI_API_KEY)
+                    models = client.models.list()
+                    st.sidebar.success("🟢 OpenAI connected")
+                except Exception as e:
+                    st.sidebar.warning(f"🟡 OpenAI connected but couldn't list models: {str(e)}")
             except ImportError:
                 st.sidebar.warning("⚠️ OpenAI SDK not installed. Run 'pip install openai'")
             except Exception as e:
@@ -63,13 +77,21 @@ class AIProviderManager:
         """Get all available models across providers"""
         models = {}
         
-        # Claude models
+        # Claude models - dynamically get if possible
         if "claude" in self.providers:
-            models.update({
-                "claude-3-sonnet-20250219": "Claude 3 Sonnet",
-                "claude-3-haiku-20250319": "Claude 3 Haiku",
-                "claude-3-opus-20250229": "Claude 3 Opus"
-            })
+            try:
+                claude_models = self.providers["claude"].models.list()
+                for model in claude_models.data:
+                    models[model.id] = f"Claude {model.id.split('-')[1].capitalize()}"
+            except Exception:
+                # Fallback to hardcoded models if API call fails
+                models.update({
+                    "claude-3-sonnet-20250219": "Claude 3 Sonnet",
+                    "claude-3-haiku-20250319": "Claude 3 Haiku",
+                    "claude-3-opus-20250229": "Claude 3 Opus",
+                    # Add additional models that might exist in 2025
+                    "claude-3-7-sonnet-20250219": "Claude 3.7 Sonnet"
+                })
         
         # OpenAI models
         if "openai" in self.providers:
@@ -101,37 +123,94 @@ class AIProviderManager:
             return self._generate_with_deepseek(prompt, model, system_prompt, temperature, max_tokens)
         
         else:
-            # Fallback to Claude if available
+            # Try to find any available provider
+            available_providers = []
             if "claude" in self.providers:
-                st.warning(f"Model {model} not available. Falling back to Claude 3 Sonnet.")
-                return self._generate_with_claude(
-                    prompt, 
-                    "claude-3-sonnet-20250219", 
-                    system_prompt, 
-                    temperature, 
-                    max_tokens
-                )
+                available_providers.append("claude")
+            if "openai" in self.providers:
+                available_providers.append("openai")
+            if "deepseek" in self.providers:
+                available_providers.append("deepseek")
+                
+            if available_providers:
+                provider = available_providers[0]
+                if provider == "claude":
+                    # Get available Claude models
+                    try:
+                        models = self.providers["claude"].models.list()
+                        if models.data:
+                            fallback_model = models.data[0].id
+                            st.warning(f"Model {model} not available. Falling back to {fallback_model}.")
+                            return self._generate_with_claude(prompt, fallback_model, system_prompt, temperature, max_tokens)
+                    except:
+                        pass
+                    # If model list fails, use hardcoded fallback
+                    st.warning(f"Model {model} not available. Falling back to Claude 3 Sonnet.")
+                    return self._generate_with_claude(prompt, "claude-3-sonnet-20250219", system_prompt, temperature, max_tokens)
+                elif provider == "openai":
+                    st.warning(f"Model {model} not available. Falling back to GPT-3.5 Turbo.")
+                    return self._generate_with_openai(prompt, "gpt-3.5-turbo", system_prompt, temperature, max_tokens)
+                elif provider == "deepseek":
+                    st.warning(f"Model {model} not available. Falling back to DeepSeek Chat.")
+                    return self._generate_with_deepseek(prompt, "deepseek-chat", system_prompt, temperature, max_tokens)
             else:
                 raise ValueError(f"No AI provider available for model: {model}")
     
     def _generate_with_claude(self, prompt: str, model: str, system_prompt: str = None, temperature: float = 0.7, max_tokens: int = 1000):
-        """Generate text using Claude"""
+        """Generate text using Claude with enhanced error handling"""
         client = self.providers["claude"]
-        
         messages = [{"role": "user", "content": prompt}]
         
-        response = client.messages.create(
-            model=model,
-            max_tokens=max_tokens,
-            temperature=temperature,
-            system=system_prompt if system_prompt else "You are a helpful assistant.",
-            messages=messages
-        )
-        
-        return response.content[0].text
+        try:
+            response = client.messages.create(
+                model=model,
+                max_tokens=max_tokens,
+                temperature=temperature,
+                system=system_prompt if system_prompt else "You are a helpful assistant.",
+                messages=messages
+            )
+            return response.content[0].text
+        except Exception as e:
+            error_msg = str(e)
+            st.error(f"Claude API Error ({model}): {error_msg}")
+            
+            # Check for model availability errors
+            if ("model" in error_msg.lower() and "not" in error_msg.lower()) or "not_found" in error_msg.lower():
+                try:
+                    # Try to get available models
+                    available_models = []
+                    try:
+                        models_list = client.models.list()
+                        available_models = [m.id for m in models_list.data]
+                        st.info(f"Available Claude models: {', '.join(available_models)}")
+                    except:
+                        # If listing fails, use fallback list
+                        available_models = ["claude-3-7-sonnet-20250219", "claude-3-sonnet-20250219", "claude-3-haiku-20250319", "claude-3-opus-20250229"]
+                    
+                    # Try available models
+                    for fallback_model in available_models:
+                        if fallback_model != model:
+                            try:
+                                st.warning(f"Trying fallback model: {fallback_model}")
+                                response = client.messages.create(
+                                    model=fallback_model,
+                                    max_tokens=max_tokens,
+                                    temperature=temperature,
+                                    system=system_prompt if system_prompt else "You are a helpful assistant.",
+                                    messages=messages
+                                )
+                                return response.content[0].text
+                            except Exception as fallback_error:
+                                st.warning(f"Fallback to {fallback_model} failed: {str(fallback_error)}")
+                                continue
+                except Exception as list_error:
+                    st.error(f"Error while attempting fallbacks: {str(list_error)}")
+            
+            # If we reach here, all fallbacks failed or it's another type of error
+            raise ValueError(f"Claude API failed with error: {error_msg}")
     
     def _generate_with_openai(self, prompt: str, model: str, system_prompt: str = None, temperature: float = 0.7, max_tokens: int = 1000):
-        """Generate text using OpenAI"""
+        """Generate text using OpenAI with enhanced error handling"""
         import openai
         
         messages = []
@@ -140,17 +219,42 @@ class AIProviderManager:
         
         messages.append({"role": "user", "content": prompt})
         
-        response = openai.chat.completions.create(
-            model=model,
-            messages=messages,
-            temperature=temperature,
-            max_tokens=max_tokens
-        )
-        
-        return response.choices[0].message.content
+        try:
+            response = openai.chat.completions.create(
+                model=model,
+                messages=messages,
+                temperature=temperature,
+                max_tokens=max_tokens
+            )
+            return response.choices[0].message.content
+        except Exception as e:
+            error_msg = str(e)
+            st.error(f"OpenAI API Error ({model}): {error_msg}")
+            
+            # Check for model availability errors
+            if "model" in error_msg.lower() and ("not" in error_msg.lower() or "find" in error_msg.lower()):
+                # Try fallback models
+                fallback_models = ["gpt-3.5-turbo", "gpt-4"]
+                for fallback_model in fallback_models:
+                    if fallback_model != model:
+                        try:
+                            st.warning(f"Trying fallback model: {fallback_model}")
+                            response = openai.chat.completions.create(
+                                model=fallback_model,
+                                messages=messages,
+                                temperature=temperature,
+                                max_tokens=max_tokens
+                            )
+                            return response.choices[0].message.content
+                        except Exception as fallback_error:
+                            st.warning(f"Fallback to {fallback_model} failed: {str(fallback_error)}")
+                            continue
+            
+            # If all fallbacks fail or it's another type of error
+            raise ValueError(f"OpenAI API failed with error: {error_msg}")
     
     def _generate_with_deepseek(self, prompt: str, model: str, system_prompt: str = None, temperature: float = 0.7, max_tokens: int = 1000):
-        """Generate text using DeepSeek"""
+        """Generate text using DeepSeek with enhanced error handling"""
         import openai as deepseek
         
         deepseek.api_key = DEEPSEEK_API_KEY
@@ -162,14 +266,46 @@ class AIProviderManager:
         
         messages.append({"role": "user", "content": prompt})
         
-        response = deepseek.chat.completions.create(
-            model="deepseek-chat" if model == "deepseek-chat" else "deepseek-coder",
-            messages=messages,
-            temperature=temperature,
-            max_tokens=max_tokens
-        )
-        
-        return response.choices[0].message.content
+        try:
+            response = deepseek.chat.completions.create(
+                model="deepseek-chat" if model == "deepseek-chat" else "deepseek-coder",
+                messages=messages,
+                temperature=temperature,
+                max_tokens=max_tokens
+            )
+            return response.choices[0].message.content
+        except Exception as e:
+            error_msg = str(e)
+            st.error(f"DeepSeek API Error ({model}): {error_msg}")
+            
+            # Check for model availability errors and try fallback
+            if model == "deepseek-chat":
+                try:
+                    st.warning("Trying fallback model: deepseek-coder")
+                    response = deepseek.chat.completions.create(
+                        model="deepseek-coder",
+                        messages=messages,
+                        temperature=temperature,
+                        max_tokens=max_tokens
+                    )
+                    return response.choices[0].message.content
+                except Exception as fallback_error:
+                    st.warning(f"Fallback failed: {str(fallback_error)}")
+            elif model == "deepseek-coder":
+                try:
+                    st.warning("Trying fallback model: deepseek-chat")
+                    response = deepseek.chat.completions.create(
+                        model="deepseek-chat",
+                        messages=messages,
+                        temperature=temperature,
+                        max_tokens=max_tokens
+                    )
+                    return response.choices[0].message.content
+                except Exception as fallback_error:
+                    st.warning(f"Fallback failed: {str(fallback_error)}")
+            
+            # If fallbacks fail or it's another type of error
+            raise ValueError(f"DeepSeek API failed with error: {error_msg}")
     
     def web_search(self, query: str) -> List[Dict[str, Any]]:
         """Perform a web search using Perplexity API"""
@@ -258,14 +394,37 @@ class AIProviderManager:
                 }}
                 """
                 
-                # Generate enhanced content
-                response = self.generate_text(
-                    prompt=prompt,
-                    model="claude-3-sonnet-20250219" if "claude" in self.providers else "gpt-4" if "openai" in self.providers else "deepseek-chat",
-                    system_prompt="You are an expert at enhancing presentation content with the latest information. Always respond with valid JSON.",
-                    temperature=0.5,
-                    max_tokens=2000
-                )
+                # Get models from available providers
+                available_models = []
+                if "claude" in self.providers:
+                    available_models.append("claude-3-7-sonnet-20250219") # Use newest model first
+                    available_models.append("claude-3-sonnet-20250219")  
+                if "openai" in self.providers:
+                    available_models.append("gpt-4")
+                    available_models.append("gpt-3.5-turbo")
+                if "deepseek" in self.providers:
+                    available_models.append("deepseek-chat")
+                
+                # Try models until one works
+                response = None
+                for model in available_models:
+                    try:
+                        response = self.generate_text(
+                            prompt=prompt,
+                            model=model,
+                            system_prompt="You are an expert at enhancing presentation content with the latest information. Always respond with valid JSON.",
+                            temperature=0.5,
+                            max_tokens=2000
+                        )
+                        if response:
+                            break
+                    except Exception as e:
+                        st.warning(f"Error using {model}: {str(e)}. Trying next model...")
+                        continue
+                
+                if not response:
+                    st.error("All models failed. Could not enhance content.")
+                    return slide_content
                 
                 # Extract the JSON from the response
                 try:
@@ -296,8 +455,10 @@ class AIProviderManager:
                         st.success("Slide enhanced with latest web information!")
                     else:
                         st.error("Could not extract JSON from AI response")
+                        st.info("Raw response: " + response[:500] + "...")  # Show part of the response for debugging
                 except Exception as e:
                     st.error(f"Error processing AI response: {str(e)}")
+                    st.info("Raw response: " + response[:500] + "...")  # Show part of the response for debugging
         
         except Exception as e:
             st.error(f"Error enhancing content with web search: {str(e)}")
@@ -334,20 +495,36 @@ class AIProviderManager:
         
         try:
             # Choose the model based on availability
-            model = "claude-3-haiku-20250319" if "claude" in self.providers else "gpt-3.5-turbo"
+            available_models = []
+            if "claude" in self.providers:
+                available_models.append("claude-3-haiku-20250319")
+            if "openai" in self.providers:
+                available_models.append("gpt-3.5-turbo")
+            if "deepseek" in self.providers:
+                available_models.append("deepseek-chat")
             
-            response = self.generate_text(
-                prompt=prompt,
-                model=model,
-                system_prompt="You are an expert at creating image generation prompts for business presentations.",
-                temperature=0.7,
-                max_tokens=200
-            )
+            # Try models until one works
+            description = None
+            for model in available_models:
+                try:
+                    description = self.generate_text(
+                        prompt=prompt,
+                        model=model,
+                        system_prompt="You are an expert at creating image generation prompts for business presentations.",
+                        temperature=0.7,
+                        max_tokens=200
+                    )
+                    if description:
+                        break
+                except Exception as e:
+                    st.warning(f"Error using {model} for image description: {str(e)}. Trying next model...")
+                    continue
             
-            # Clean up the response
-            description = response.strip()
+            if not description:
+                return f"An image representing {title}"
             
-            return description
+            # Clean up the response
+            return description.strip()
         except Exception as e:
             st.error(f"Error generating image description: {str(e)}")
             return f"An image representing {title}"
@@ -358,4 +535,59 @@ def get_ai_manager():
     if 'ai_manager' not in st.session_state:
         st.session_state.ai_manager = AIProviderManager()
     
-    return st.session_state.ai_manager
+    return st.session_state.ai_manager
+
+# Add a diagnostic function to test model availability
+def test_models():
+    """Test model availability across providers"""
+    ai_manager = get_ai_manager()
+    
+    st.write("### LLM Provider Diagnostics")
+    
+    # Test Claude
+    if "claude" in ai_manager.providers:
+        try:
+            st.write("#### Testing Claude API:")
+            claude = ai_manager.providers["claude"]
+            models = claude.models.list()
+            st.success(f"Available Claude models:")
+            for model in models.data:
+                st.write(f"- {model.id}")
+                
+            # Test a quick generation
+            test_prompt = "Say hello in one word."
+            with st.spinner(f"Testing with {models.data[0].id}..."):
+                response = claude.messages.create(
+                    model=models.data[0].id,
+                    max_tokens=10,
+                    messages=[{"role": "user", "content": test_prompt}]
+                )
+                st.success(f"Test response: {response.content[0].text}")
+        except Exception as e:
+            st.error(f"Claude API test failed: {str(e)}")
+    else:
+        st.warning("Claude API not configured")
+    
+    # Test OpenAI
+    if "openai" in ai_manager.providers:
+        try:
+            st.write("#### Testing OpenAI API:")
+            import openai
+            client = openai.OpenAI(api_key=OPENAI_API_KEY)
+            models = client.models.list()
+            st.success(f"Available OpenAI models:")
+            for model in models.data[:5]:  # Show first 5 to avoid cluttering
+                st.write(f"- {model.id}")
+                
+            # Test a quick generation
+            test_prompt = "Say hello in one word."
+            with st.spinner("Testing with gpt-3.5-turbo..."):
+                response = client.chat.completions.create(
+                    model="gpt-3.5-turbo",
+                    messages=[{"role": "user", "content": test_prompt}]
+                )
+                st.success(f"Test response: {response.choices[0].message.content}")
+        except Exception as e:
+            st.error(f"OpenAI API test failed: {str(e)}")
+    else:
+        st.warning("OpenAI API not configured")