Update llm_factory.py

llm_factory.py

@@ -2,7 +2,7 @@
 LLM Provider Factory for Flare
 """
 import os
-from typing import Optional
+from typing import Optional, Dict, Any
 from dotenv import load_dotenv
 
 from llm_interface import LLMInterface, SparkLLM, GPT4oLLM
@@ -10,58 +10,64 @@ from config_provider import ConfigProvider
 from utils import log
 
 class LLMFactory:
-    """Factory class to create appropriate LLM provider based on configuration"""
+    """Factory class to create appropriate LLM provider based on llm_provider config"""
     
     @staticmethod
     def create_provider() -> LLMInterface:
         """Create and return appropriate LLM provider based on config"""
         cfg = ConfigProvider.get()
-        llm_config = cfg.global_config.llm_provider
+        llm_provider = cfg.global_config.llm_provider
         
-        if not llm_config:
+        if not llm_provider or not llm_provider.name:
             raise ValueError("No LLM provider configured")
         
-        provider_name = llm_config.name
+        provider_name = llm_provider.name
         log(f"🏭 Creating LLM provider: {provider_name}")
         
-        # Get provider definition
-        provider_def = cfg.global_config.get_provider_config("llm", provider_name)
-        if not provider_def:
+        # Get provider config
+        provider_config = cfg.global_config.get_provider_config("llm", provider_name)
+        if not provider_config:
             raise ValueError(f"Unknown LLM provider: {provider_name}")
         
         # Get API key
         api_key = LLMFactory._get_api_key(provider_name)
-        if not api_key and provider_def.requires_api_key:
+        if not api_key and provider_config.requires_api_key:
             raise ValueError(f"API key required for {provider_name} but not configured")
         
-        # Get endpoint
-        endpoint = llm_config.endpoint
-        if not endpoint and provider_def.requires_endpoint:
-            raise ValueError(f"Endpoint required for {provider_name} but not configured")
+        # Get settings
+        settings = llm_provider.settings or {}
         
         # Create appropriate provider
-        if provider_name in ("spark", "spark_cloud", "spark_onpremise"):
-            return LLMFactory._create_spark_provider(provider_name, api_key, endpoint, llm_config.settings)
+        if provider_name == "spark":
+            return LLMFactory._create_spark_provider(api_key, llm_provider.endpoint, settings)
         elif provider_name in ("gpt4o", "gpt4o-mini"):
-            return LLMFactory._create_gpt_provider(provider_name, api_key, llm_config.settings)
+            return LLMFactory._create_gpt_provider(provider_name, api_key, settings)
         else:
             raise ValueError(f"Unsupported LLM provider: {provider_name}")
     
     @staticmethod
-    def _create_spark_provider(provider_name: str, api_key: str, endpoint: str, settings: dict) -> SparkLLM:
+    def _create_spark_provider(api_key: str, endpoint: Optional[str], settings: Dict[str, Any]) -> SparkLLM:
         """Create Spark LLM provider"""
-        log(f"🚀 Creating SparkLLM provider: {provider_name}")
+        if not endpoint:
+            raise ValueError("Spark requires endpoint to be configured")
+        
+        log(f"🚀 Creating SparkLLM provider")
         log(f"📍 Endpoint: {endpoint}")
         
+        # Determine provider variant for backward compatibility
+        provider_variant = "spark-cloud"
+        if not ConfigProvider.get().global_config.is_cloud_mode():
+            provider_variant = "spark-onpremise"
+        
         return SparkLLM(
-            spark_endpoint=endpoint,
+            spark_endpoint=str(endpoint),
             spark_token=api_key,
-            provider_variant=provider_name,
+            provider_variant=provider_variant,
             settings=settings
         )
     
     @staticmethod
-    def _create_gpt_provider(model_type: str, api_key: str, settings: dict) -> GPT4oLLM:
+    def _create_gpt_provider(model_type: str, api_key: str, settings: Dict[str, Any]) -> GPT4oLLM:
         """Create GPT-4o LLM provider"""
         # Determine model
         model = "gpt-4o-mini" if model_type == "gpt4o-mini" else "gpt-4o"
@@ -88,8 +94,6 @@ class LLMFactory:
         # Then check environment based on provider
         env_var_map = {
             "spark": "SPARK_TOKEN",
-            "spark_cloud": "SPARK_TOKEN",
-            "spark_onpremise": "SPARK_TOKEN",
             "gpt4o": "OPENAI_API_KEY",
             "gpt4o-mini": "OPENAI_API_KEY",
         }
@@ -101,11 +105,13 @@ class LLMFactory:
                 api_key = os.environ.get(env_var)
                 if api_key:
                     log(f"🔑 Using {env_var} from HuggingFace secrets")
+                    return api_key
             else:
-                # Local/on-premise deployment
+                # Local development
                 load_dotenv()
                 api_key = os.getenv(env_var)
                 if api_key:
                     log(f"🔑 Using {env_var} from .env file")
+                    return api_key
         
-        return api_key
+        return None