Update llm_factory.py

llm_factory.py

@@ -10,59 +10,58 @@ from config_provider import ConfigProvider
 from utils import log
 
 class LLMFactory:
-    """Factory class to create appropriate LLM provider based on llm_provider config"""
+    """Factory class to create appropriate LLM provider based on configuration"""
     
     @staticmethod
     def create_provider() -> LLMInterface:
         """Create and return appropriate LLM provider based on config"""
         cfg = ConfigProvider.get()
-        llm_provider = cfg.global_config.llm_provider
+        llm_config = cfg.global_config.llm_provider
         
-        log(f"🏭 Creating LLM provider: {llm_provider}")
+        if not llm_config:
+            raise ValueError("No LLM provider configured")
         
-        # Get provider config
-        provider_config = cfg.global_config.get_llm_provider_config()
-        if not provider_config:
-            raise ValueError(f"Unknown LLM provider: {llm_provider}")
+        provider_name = llm_config.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:
+            raise ValueError(f"Unknown LLM provider: {provider_name}")
         
         # Get API key
-        api_key = LLMFactory._get_api_key()
-        if not api_key and provider_config.requires_api_key:
-            raise ValueError(f"API key required for {llm_provider} but not configured")
+        api_key = LLMFactory._get_api_key(provider_name)
+        if not api_key and provider_def.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")
         
         # Create appropriate provider
-        if llm_provider == "spark":
-            return LLMFactory._create_spark_provider(api_key)
-        elif llm_provider in ("gpt4o", "gpt4o-mini"):
-            return LLMFactory._create_gpt_provider(llm_provider, api_key)
+        if provider_name in ("spark", "spark_cloud", "spark_onpremise"):
+            return LLMFactory._create_spark_provider(provider_name, api_key, endpoint, llm_config.settings)
+        elif provider_name in ("gpt4o", "gpt4o-mini"):
+            return LLMFactory._create_gpt_provider(provider_name, api_key, llm_config.settings)
         else:
-            raise ValueError(f"Unsupported LLM provider: {llm_provider}")
+            raise ValueError(f"Unsupported LLM provider: {provider_name}")
     
     @staticmethod
-    def _create_spark_provider(api_key: str) -> SparkLLM:
+    def _create_spark_provider(provider_name: str, api_key: str, endpoint: str, settings: dict) -> SparkLLM:
         """Create Spark LLM provider"""
-        cfg = ConfigProvider.get()
-        
-        endpoint = cfg.global_config.llm_provider_endpoint
-        if not endpoint:
-            raise ValueError("Spark requires llm_provider_endpoint to be configured")
-        
-        log(f"🚀 Creating SparkLLM provider")
+        log(f"🚀 Creating SparkLLM provider: {provider_name}")
         log(f"📍 Endpoint: {endpoint}")
         
-        # Determine work mode for Spark (backward compatibility)
-        work_mode = "cloud"  # Default
-        if not cfg.global_config.is_cloud_mode():
-            work_mode = "on-premise"
-        
         return SparkLLM(
-            spark_endpoint=str(endpoint),
+            spark_endpoint=endpoint,
             spark_token=api_key,
-            work_mode=work_mode
+            provider_variant=provider_name,
+            settings=settings
         )
     
     @staticmethod
-    def _create_gpt_provider(model_type: str, api_key: str) -> GPT4oLLM:
+    def _create_gpt_provider(model_type: str, api_key: str, settings: dict) -> GPT4oLLM:
         """Create GPT-4o LLM provider"""
         # Determine model
         model = "gpt-4o-mini" if model_type == "gpt4o-mini" else "gpt-4o"
@@ -71,37 +70,39 @@ class LLMFactory:
         
         return GPT4oLLM(
             api_key=api_key,
-            model=model
+            model=model,
+            settings=settings
         )
     
     @staticmethod
-    def _get_api_key() -> Optional[str]:
+    def _get_api_key(provider_name: str) -> Optional[str]:
         """Get API key from config or environment"""
         cfg = ConfigProvider.get()
         
         # First check encrypted config
-        api_key = cfg.global_config.get_plain_api_key()
+        api_key = cfg.global_config.get_plain_api_key("llm")
         if api_key:
             log("🔑 Using decrypted API key from config")
             return api_key
         
         # Then check environment based on provider
-        llm_provider = cfg.global_config.llm_provider
-        
         env_var_map = {
             "spark": "SPARK_TOKEN",
+            "spark_cloud": "SPARK_TOKEN",
+            "spark_onpremise": "SPARK_TOKEN",
             "gpt4o": "OPENAI_API_KEY",
             "gpt4o-mini": "OPENAI_API_KEY",
-            # Add more mappings as needed
         }
         
-        env_var = env_var_map.get(llm_provider)
+        env_var = env_var_map.get(provider_name)
         if env_var:
-            if cfg.global_config.is_cloud_mode():
+            # Check if running in HuggingFace Space
+            if os.environ.get("SPACE_ID"):
                 api_key = os.environ.get(env_var)
                 if api_key:
-                    log(f"🔑 Using {env_var} from environment")
+                    log(f"🔑 Using {env_var} from HuggingFace secrets")
             else:
+                # Local/on-premise deployment
                 load_dotenv()
                 api_key = os.getenv(env_var)
                 if api_key: