aiecs 1.2.0__py3-none-any.whl → 1.2.1__py3-none-any.whl

aiecs/llm/{base_client.py → clients/base_client.py}

@@ -6,6 +6,12 @@ import logging
 
 logger = logging.getLogger(__name__)
 
+# Lazy import to avoid circular dependency
+def _get_config_loader():
+    """Lazy import of config loader to avoid circular dependency"""
+    from aiecs.llm.config import get_llm_config_loader
+    return get_llm_config_loader()
+
 @dataclass
 class LLMMessage:
     role: str  # "system", "user", "assistant"
@@ -93,8 +99,74 @@ class BaseLLMClient(ABC):
         return len(text) // 4
 
     def _estimate_cost(self, model: str, input_tokens: int, output_tokens: int, token_costs: Dict) -> float:
-        """Estimate the cost of the API call"""
+        """
+        Estimate the cost of the API call.
+        
+        DEPRECATED: Use _estimate_cost_from_config instead for config-based cost estimation.
+        This method is kept for backward compatibility.
+        """
         if model in token_costs:
             costs = token_costs[model]
             return (input_tokens * costs["input"] + output_tokens * costs["output"]) / 1000
         return 0.0
+    
+    def _estimate_cost_from_config(self, model_name: str, input_tokens: int, output_tokens: int) -> float:
+        """
+        Estimate the cost using configuration-based pricing.
+        
+        Args:
+            model_name: Name of the model
+            input_tokens: Number of input tokens
+            output_tokens: Number of output tokens
+        
+        Returns:
+            Estimated cost in USD
+        """
+        try:
+            loader = _get_config_loader()
+            model_config = loader.get_model_config(self.provider_name, model_name)
+            
+            if model_config and model_config.costs:
+                input_cost = (input_tokens * model_config.costs.input) / 1000
+                output_cost = (output_tokens * model_config.costs.output) / 1000
+                return input_cost + output_cost
+            else:
+                self.logger.warning(
+                    f"No cost configuration found for model {model_name} "
+                    f"in provider {self.provider_name}"
+                )
+                return 0.0
+        except Exception as e:
+            self.logger.warning(f"Failed to estimate cost from config: {e}")
+            return 0.0
+    
+    def _get_model_config(self, model_name: str):
+        """
+        Get model configuration from the config loader.
+        
+        Args:
+            model_name: Name of the model
+        
+        Returns:
+            ModelConfig if found, None otherwise
+        """
+        try:
+            loader = _get_config_loader()
+            return loader.get_model_config(self.provider_name, model_name)
+        except Exception as e:
+            self.logger.warning(f"Failed to get model config: {e}")
+            return None
+    
+    def _get_default_model(self) -> Optional[str]:
+        """
+        Get the default model for this provider from configuration.
+        
+        Returns:
+            Default model name if configured, None otherwise
+        """
+        try:
+            loader = _get_config_loader()
+            return loader.get_default_model(self.provider_name)
+        except Exception as e:
+            self.logger.warning(f"Failed to get default model: {e}")
+            return None

aiecs/llm/{googleai_client.py → clients/googleai_client.py}

@@ -6,7 +6,7 @@ from typing import Dict, Any, Optional, List, AsyncGenerator
 import google.generativeai as genai
 from google.generativeai.types import GenerationConfig, HarmCategory, HarmBlockThreshold
 
-from aiecs.llm.base_client import BaseLLMClient, LLMMessage, LLMResponse, ProviderNotAvailableError, RateLimitError
+from aiecs.llm.clients.base_client import BaseLLMClient, LLMMessage, LLMResponse, ProviderNotAvailableError, RateLimitError
 from aiecs.config.config import get_settings
 
 logger = logging.getLogger(__name__)
@@ -20,12 +20,6 @@ class GoogleAIClient(BaseLLMClient):
         self._initialized = False
         self.client = None
 
-        # Token cost estimates for Gemini 2.5 series
-        self.token_costs = {
-            "gemini-2.5-pro": {"input": 0.00125, "output": 0.00375},
-            "gemini-2.5-flash": {"input": 0.000075, "output": 0.0003},
-        }
-
     def _init_google_ai(self):
         """Lazy initialization of Google AI SDK"""
         if not self._initialized:
@@ -50,7 +44,14 @@ class GoogleAIClient(BaseLLMClient):
     ) -> LLMResponse:
         """Generate text using Google AI"""
         self._init_google_ai()
-        model_name = model or "gemini-2.5-pro"
+        
+        # Get model name from config if not provided
+        model_name = model or self._get_default_model() or "gemini-2.5-pro"
+        
+        # Get model config for default parameters
+        model_config = self._get_model_config(model_name)
+        if model_config and max_tokens is None:
+            max_tokens = model_config.default_params.max_tokens
 
         try:
             model_instance = genai.GenerativeModel(model_name)
@@ -88,12 +89,8 @@ class GoogleAIClient(BaseLLMClient):
             completion_tokens = response.usage_metadata.candidates_token_count
             total_tokens = response.usage_metadata.total_token_count
 
-            cost = self._estimate_cost(
-                model_name,
-                prompt_tokens,
-                completion_tokens,
-                self.token_costs
-            )
+            # Use config-based cost estimation
+            cost = self._estimate_cost_from_config(model_name, prompt_tokens, completion_tokens)
 
             return LLMResponse(
                 content=content,
@@ -121,7 +118,14 @@ class GoogleAIClient(BaseLLMClient):
     ) -> AsyncGenerator[str, None]:
         """Stream text generation using Google AI"""
         self._init_google_ai()
-        model_name = model or "gemini-2.5-pro"
+        
+        # Get model name from config if not provided
+        model_name = model or self._get_default_model() or "gemini-2.5-pro"
+        
+        # Get model config for default parameters
+        model_config = self._get_model_config(model_name)
+        if model_config and max_tokens is None:
+            max_tokens = model_config.default_params.max_tokens
 
         try:
             model_instance = genai.GenerativeModel(model_name)

aiecs/llm/{openai_client.py → clients/openai_client.py}

@@ -5,7 +5,7 @@ from openai import AsyncOpenAI
 from tenacity import retry, stop_after_attempt, wait_exponential, retry_if_exception_type
 import httpx
 
-from aiecs.llm.base_client import BaseLLMClient, LLMMessage, LLMResponse, ProviderNotAvailableError, RateLimitError
+from aiecs.llm.clients.base_client import BaseLLMClient, LLMMessage, LLMResponse, ProviderNotAvailableError, RateLimitError
 from aiecs.config.config import get_settings
 
 logger = logging.getLogger(__name__)
@@ -18,15 +18,6 @@ class OpenAIClient(BaseLLMClient):
         self.settings = get_settings()
         self._client: Optional[AsyncOpenAI] = None
 
-        # Token cost estimates (USD per 1K tokens)
-        self.token_costs = {
-            "gpt-4": {"input": 0.03, "output": 0.06},
-            "gpt-4-turbo": {"input": 0.01, "output": 0.03},
-            "gpt-3.5-turbo": {"input": 0.0015, "output": 0.002},
-            "gpt-4o": {"input": 0.005, "output": 0.015},
-            "gpt-4o-mini": {"input": 0.00015, "output": 0.0006},
-        }
-
     def _get_client(self) -> AsyncOpenAI:
         """Lazy initialization of OpenAI client"""
         if not self._client:
@@ -50,7 +41,9 @@ class OpenAIClient(BaseLLMClient):
     ) -> LLMResponse:
         """Generate text using OpenAI API"""
         client = self._get_client()
-        model = model or "gpt-4-turbo"
+        
+        # Get model name from config if not provided
+        model = model or self._get_default_model() or "gpt-4-turbo"
 
         # Convert to OpenAI message format
         openai_messages = [{"role": msg.role, "content": msg.content} for msg in messages]
@@ -67,10 +60,10 @@ class OpenAIClient(BaseLLMClient):
             content = response.choices[0].message.content
             tokens_used = response.usage.total_tokens if response.usage else None
 
-            # Estimate cost
+            # Estimate cost using config
             input_tokens = response.usage.prompt_tokens if response.usage else 0
             output_tokens = response.usage.completion_tokens if response.usage else 0
-            cost = self._estimate_cost(model, input_tokens, output_tokens, self.token_costs)
+            cost = self._estimate_cost_from_config(model, input_tokens, output_tokens)
 
             return LLMResponse(
                 content=content,
@@ -95,7 +88,9 @@ class OpenAIClient(BaseLLMClient):
     ) -> AsyncGenerator[str, None]:
         """Stream text using OpenAI API"""
         client = self._get_client()
-        model = model or "gpt-4-turbo"
+        
+        # Get model name from config if not provided
+        model = model or self._get_default_model() or "gpt-4-turbo"
 
         openai_messages = [{"role": msg.role, "content": msg.content} for msg in messages]
 

aiecs/llm/{vertex_client.py → clients/vertex_client.py}

@@ -6,7 +6,7 @@ import vertexai
 from vertexai.generative_models import GenerativeModel, HarmCategory, HarmBlockThreshold, GenerationConfig, SafetySetting
 from google.oauth2 import service_account
 
-from aiecs.llm.base_client import BaseLLMClient, LLMMessage, LLMResponse, ProviderNotAvailableError, RateLimitError
+from aiecs.llm.clients.base_client import BaseLLMClient, LLMMessage, LLMResponse, ProviderNotAvailableError, RateLimitError
 from aiecs.config.config import get_settings
 
 logger = logging.getLogger(__name__)
@@ -19,12 +19,6 @@ class VertexAIClient(BaseLLMClient):
         self.settings = get_settings()
         self._initialized = False
 
-        # Token cost estimates (USD per 1K tokens)
-        self.token_costs = {
-            "gemini-2.5-pro": {"input": 0.00125, "output": 0.00375},
-            "gemini-2.5-flash": {"input": 0.000075, "output": 0.0003},
-        }
-
     def _init_vertex_ai(self):
         """Lazy initialization of Vertex AI with proper authentication"""
         if not self._initialized:
@@ -71,7 +65,14 @@ class VertexAIClient(BaseLLMClient):
     ) -> LLMResponse:
         """Generate text using Vertex AI"""
         self._init_vertex_ai()
-        model_name = model or "gemini-2.5-pro"
+        
+        # Get model name from config if not provided
+        model_name = model or self._get_default_model() or "gemini-2.5-pro"
+        
+        # Get model config for default parameters
+        model_config = self._get_model_config(model_name)
+        if model_config and max_tokens is None:
+            max_tokens = model_config.default_params.max_tokens
 
         try:
             # Use the stable Vertex AI API
@@ -163,13 +164,12 @@ class VertexAIClient(BaseLLMClient):
                     content = "[Response error: Cannot get the response text. Multiple content parts are not supported.]"
 
             # Vertex AI doesn't provide detailed token usage in the response
-            tokens_used = self._count_tokens_estimate(prompt + content)
-            cost = self._estimate_cost(
-                model_name,
-                self._count_tokens_estimate(prompt),
-                self._count_tokens_estimate(content),
-                self.token_costs
-            )
+            input_tokens = self._count_tokens_estimate(prompt)
+            output_tokens = self._count_tokens_estimate(content)
+            tokens_used = input_tokens + output_tokens
+            
+            # Use config-based cost estimation
+            cost = self._estimate_cost_from_config(model_name, input_tokens, output_tokens)
 
             return LLMResponse(
                 content=content,

aiecs/llm/{xai_client.py → clients/xai_client.py}

@@ -2,10 +2,17 @@ import json
 import asyncio
 import logging
 from typing import Dict, Any, Optional, List, AsyncGenerator
+
+# Lazy import to avoid circular dependency
+def _get_config_loader():
+    """Lazy import of config loader to avoid circular dependency"""
+    from aiecs.llm.config import get_llm_config_loader
+    return get_llm_config_loader()
+
 from openai import AsyncOpenAI
 from tenacity import retry, stop_after_attempt, wait_exponential, retry_if_exception_type
 
-from aiecs.llm.base_client import BaseLLMClient, LLMMessage, LLMResponse, ProviderNotAvailableError, RateLimitError
+from aiecs.llm.clients.base_client import BaseLLMClient, LLMMessage, LLMResponse, ProviderNotAvailableError, RateLimitError
 from aiecs.config.config import get_settings
 
 logger = logging.getLogger(__name__)
@@ -17,51 +24,7 @@ class XAIClient(BaseLLMClient):
         super().__init__("xAI")
         self.settings = get_settings()
         self._openai_client: Optional[AsyncOpenAI] = None
-
-        # Enhanced model mapping for all Grok models
-        self.model_map = {
-            # Legacy Grok models
-            "grok-beta": "grok-beta",
-            "grok": "grok-beta",
-
-            # Current Grok models
-            "Grok 2": "grok-2",
-            "grok-2": "grok-2",
-            "Grok 2 Vision": "grok-2-vision",
-            "grok-2-vision": "grok-2-vision",
-
-            # Grok 3 models
-            "Grok 3 Normal": "grok-3",
-            "grok-3": "grok-3",
-            "Grok 3 Fast": "grok-3-fast",
-            "grok-3-fast": "grok-3-fast",
-
-            # Grok 3 Mini models
-            "Grok 3 Mini Normal": "grok-3-mini",
-            "grok-3-mini": "grok-3-mini",
-            "Grok 3 Mini Fast": "grok-3-mini-fast",
-            "grok-3-mini-fast": "grok-3-mini-fast",
-
-            # Grok 3 Reasoning models
-            "Grok 3 Reasoning Normal": "grok-3-reasoning",
-            "grok-3-reasoning": "grok-3-reasoning",
-            "Grok 3 Reasoning Fast": "grok-3-reasoning-fast",
-            "grok-3-reasoning-fast": "grok-3-reasoning-fast",
-
-            # Grok 3 Mini Reasoning models
-            "Grok 3 Mini Reasoning Normal": "grok-3-mini-reasoning",
-            "grok-3-mini-reasoning": "grok-3-mini-reasoning",
-            "Grok 3 Mini Reasoning Fast": "grok-3-mini-reasoning-fast",
-            "grok-3-mini-reasoning-fast": "grok-3-mini-reasoning-fast",
-
-            # Grok 4 models
-            "Grok 4 Normal": "grok-4",
-            "grok-4": "grok-4",
-            "Grok 4 Fast": "grok-4-fast",
-            "grok-4-fast": "grok-4-fast",
-            "Grok 4 0709": "grok-4-0709",
-            "grok-4-0709": "grok-4-0709",
-        }
+        self._model_map: Optional[Dict[str, str]] = None
 
     def _get_openai_client(self) -> AsyncOpenAI:
         """Lazy initialization of OpenAI client for XAI"""
@@ -81,6 +44,21 @@ class XAIClient(BaseLLMClient):
         if not api_key:
             raise ProviderNotAvailableError("xAI API key not configured")
         return api_key
+    
+    def _get_model_map(self) -> Dict[str, str]:
+        """Get model mappings from configuration"""
+        if self._model_map is None:
+            try:
+                loader = _get_config_loader()
+                provider_config = loader.get_provider_config("xAI")
+                if provider_config and provider_config.model_mappings:
+                    self._model_map = provider_config.model_mappings
+                else:
+                    self._model_map = {}
+            except Exception as e:
+                self.logger.warning(f"Failed to load model mappings from config: {e}")
+                self._model_map = {}
+        return self._model_map
 
     @retry(
         stop=stop_after_attempt(3),
@@ -103,8 +81,12 @@ class XAIClient(BaseLLMClient):
 
         client = self._get_openai_client()
 
-        selected_model = model or "grok-4"  # Default to grok-4 as in the example
-        api_model = self.model_map.get(selected_model, selected_model)
+        # Get model name from config if not provided
+        selected_model = model or self._get_default_model() or "grok-4"
+        
+        # Get model mappings from config
+        model_map = self._get_model_map()
+        api_model = model_map.get(selected_model, selected_model)
 
         # Convert to OpenAI format
         openai_messages = [{"role": msg.role, "content": msg.content} for msg in messages]
@@ -151,8 +133,12 @@ class XAIClient(BaseLLMClient):
 
         client = self._get_openai_client()
 
-        selected_model = model or "grok-4"  # Default to grok-4
-        api_model = self.model_map.get(selected_model, selected_model)
+        # Get model name from config if not provided
+        selected_model = model or self._get_default_model() or "grok-4"
+        
+        # Get model mappings from config
+        model_map = self._get_model_map()
+        api_model = model_map.get(selected_model, selected_model)
 
         # Convert to OpenAI format
         openai_messages = [{"role": msg.role, "content": msg.content} for msg in messages]

aiecs/llm/config/__init__.py

@@ -0,0 +1,54 @@
+"""
+LLM Configuration management.
+
+This package handles configuration loading, validation, and management
+for all LLM providers and models.
+"""
+
+from .model_config import (
+    ModelCostConfig,
+    ModelCapabilities,
+    ModelDefaultParams,
+    ModelConfig,
+    ProviderConfig,
+    LLMModelsConfig
+)
+from .config_loader import (
+    LLMConfigLoader,
+    get_llm_config_loader,
+    get_llm_config,
+    reload_llm_config
+)
+from .config_validator import (
+    ConfigValidationError,
+    validate_cost_config,
+    validate_model_config,
+    validate_provider_config,
+    validate_llm_config,
+    validate_config_file
+)
+
+__all__ = [
+    # Configuration models
+    "ModelCostConfig",
+    "ModelCapabilities",
+    "ModelDefaultParams",
+    "ModelConfig",
+    "ProviderConfig",
+    "LLMModelsConfig",
+    
+    # Config loader
+    "LLMConfigLoader",
+    "get_llm_config_loader",
+    "get_llm_config",
+    "reload_llm_config",
+    
+    # Validation
+    "ConfigValidationError",
+    "validate_cost_config",
+    "validate_model_config",
+    "validate_provider_config",
+    "validate_llm_config",
+    "validate_config_file",
+]
+