aiecs 1.2.0__tar.gz → 1.2.2__tar.gz

{aiecs-1.2.0/aiecs.egg-info → aiecs-1.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aiecs
-Version: 1.2.0
+Version: 1.2.2
 Summary: AI Execute Services - A middleware framework for AI-powered task execution and tool orchestration
 Author-email: AIECS Team <iretbl@gmail.com>
 License-Expression: MIT

{aiecs-1.2.0 → aiecs-1.2.2}/aiecs/__init__.py

@@ -5,7 +5,7 @@ A powerful Python middleware framework for building AI-powered applications
 with tool orchestration, task execution, and multi-provider LLM support.
 """
 
-__version__ = "1.2.0"
+__version__ = "1.2.2"
 __author__ = "AIECS Team"
 __email__ = "iretbl@gmail.com"
 

{aiecs-1.2.0 → aiecs-1.2.2}/aiecs/aiecs_client.py

@@ -12,7 +12,7 @@ from aiecs.config.config import get_settings, validate_required_settings
 from aiecs.domain.task.task_context import TaskContext
 from aiecs.tools import discover_tools, list_tools, get_tool
 from aiecs.llm.client_factory import LLMClientFactory, LLMClientManager, AIProvider
-from aiecs.llm.base_client import LLMMessage
+from aiecs.llm.clients.base_client import LLMMessage
 
 logger = logging.getLogger(__name__)
 

{aiecs-1.2.0 → aiecs-1.2.2}/aiecs/config/config.py

@@ -1,6 +1,7 @@
 from pydantic import Field, ConfigDict
 from pydantic_settings import BaseSettings
 from functools import lru_cache
+from pathlib import Path
 
 class Settings(BaseSettings):
     # LLM Provider Configuration (optional until used)
@@ -14,6 +15,13 @@ class Settings(BaseSettings):
     xai_api_key: str = Field(default="", alias="XAI_API_KEY")
     grok_api_key: str = Field(default="", alias="GROK_API_KEY")  # Backward compatibility
     
+    # LLM Models Configuration
+    llm_models_config_path: str = Field(
+        default="",
+        alias="LLM_MODELS_CONFIG",
+        description="Path to LLM models YAML configuration file"
+    )
+    
     # Infrastructure Configuration (with sensible defaults)
     celery_broker_url: str = Field(default="redis://localhost:6379/0", alias="CELERY_BROKER_URL")
     cors_allowed_origins: str = Field(default="http://localhost:3000,http://express-gateway:3001", alias="CORS_ALLOWED_ORIGINS")
@@ -46,7 +54,7 @@ class Settings(BaseSettings):
     reload: bool = Field(default=False, alias="RELOAD")
     port: int = Field(default=8000, alias="PORT")
 
-    model_config = ConfigDict(env_file=".env", env_file_encoding="utf-8")
+    model_config = ConfigDict(env_file=".env", env_file_encoding="utf-8", extra="allow")
 
     @property
     def database_config(self) -> dict:
@@ -70,6 +78,35 @@ class Settings(BaseSettings):
             "local_storage_path": "./storage"
         }
 
+    
+    def validate_llm_models_config(self) -> bool:
+        """
+        Validate that LLM models configuration file exists.
+        
+        Returns:
+            True if config file exists or can be found in default locations
+        
+        Raises:
+            FileNotFoundError: If config file doesn't exist
+        """
+        if self.llm_models_config_path:
+            config_path = Path(self.llm_models_config_path)
+            if not config_path.exists():
+                raise FileNotFoundError(
+                    f"LLM models config file not found: {config_path}"
+                )
+            return True
+        
+        # Check default locations
+        current_dir = Path(__file__).parent
+        default_path = current_dir / "llm_models.yaml"
+        
+        if default_path.exists():
+            return True
+        
+        # If not found, it's still okay - the config loader will try to find it
+        return True
+
 @lru_cache()
 def get_settings():
     return Settings()

aiecs-1.2.2/aiecs/infrastructure/monitoring/__init__.py

@@ -0,0 +1,34 @@
+"""Infrastructure monitoring module
+
+Contains monitoring, metrics, and observability infrastructure.
+"""
+
+from .executor_metrics import ExecutorMetrics
+from .tracing_manager import TracingManager
+from .global_metrics_manager import (
+    initialize_global_metrics,
+    get_global_metrics,
+    close_global_metrics,
+    is_metrics_initialized,
+    get_metrics_summary,
+    record_operation,
+    record_duration,
+    record_operation_success,
+    record_operation_failure,
+    record_retry
+)
+
+__all__ = [
+    "ExecutorMetrics",
+    "TracingManager",
+    "initialize_global_metrics",
+    "get_global_metrics",
+    "close_global_metrics",
+    "is_metrics_initialized",
+    "get_metrics_summary",
+    "record_operation",
+    "record_duration",
+    "record_operation_success",
+    "record_operation_failure",
+    "record_retry",
+]

aiecs-1.2.2/aiecs/infrastructure/monitoring/global_metrics_manager.py

@@ -0,0 +1,207 @@
+"""
+Global Metrics Manager
+
+This module provides a singleton ExecutorMetrics instance that can be shared
+across all components in the application. It follows the same pattern as
+other global managers in the infrastructure layer.
+
+Usage:
+    # In main.py startup:
+    await initialize_global_metrics()
+    
+    # In any component:
+    from aiecs.infrastructure.monitoring.global_metrics_manager import get_global_metrics
+    metrics = get_global_metrics()
+"""
+
+import logging
+import asyncio
+import os
+from typing import Optional, Dict, Any
+from .executor_metrics import ExecutorMetrics
+
+logger = logging.getLogger(__name__)
+
+# Global singleton instance
+_global_metrics: Optional[ExecutorMetrics] = None
+_initialization_lock = asyncio.Lock()
+_initialized = False
+
+
+async def initialize_global_metrics(
+    enable_metrics: bool = True,
+    metrics_port: Optional[int] = None,
+    config: Optional[Dict[str, Any]] = None
+) -> Optional[ExecutorMetrics]:
+    """
+    Initialize the global ExecutorMetrics instance.
+    
+    This should be called once during application startup (in main.py lifespan).
+    
+    Args:
+        enable_metrics: Whether to enable metrics collection (default: True)
+        metrics_port: Port for metrics server (default: from env or 8001)
+        config: Additional configuration options
+        
+    Returns:
+        The initialized ExecutorMetrics instance or None if initialization fails
+        
+    Example:
+        @asynccontextmanager
+        async def lifespan(app: FastAPI):
+            # Startup
+            await initialize_global_metrics()
+            yield
+            # Shutdown
+            await close_global_metrics()
+    """
+    global _global_metrics, _initialized
+    
+    if _initialized and _global_metrics:
+        logger.info("Global metrics already initialized")
+        return _global_metrics
+    
+    async with _initialization_lock:
+        # Double-check after acquiring lock
+        if _initialized and _global_metrics:
+            return _global_metrics
+        
+        try:
+            # Determine metrics port
+            if metrics_port is None:
+                metrics_port = int(os.environ.get("METRICS_PORT", "8001"))
+            
+            # Check if metrics should be enabled
+            if not enable_metrics:
+                enable_metrics = os.environ.get("ENABLE_METRICS", "true").lower() == "true"
+            
+            logger.info(f"Initializing global metrics (port: {metrics_port}, enabled: {enable_metrics})...")
+            
+            # Create metrics instance
+            _global_metrics = ExecutorMetrics(
+                enable_metrics=enable_metrics,
+                metrics_port=metrics_port
+            )
+            
+            _initialized = True
+            logger.info("✅ Global metrics initialized successfully")
+            return _global_metrics
+            
+        except Exception as e:
+            logger.error(f"❌ Failed to initialize global metrics: {e}")
+            logger.warning("Application will continue without metrics (degraded mode)")
+            _global_metrics = None
+            _initialized = False
+            return None
+
+
+def get_global_metrics() -> Optional[ExecutorMetrics]:
+    """
+    Get the global ExecutorMetrics instance.
+    
+    Returns:
+        The global ExecutorMetrics instance or None if not initialized
+        
+    Raises:
+        RuntimeError: If metrics are requested but not initialized
+        
+    Example:
+        metrics = get_global_metrics()
+        if metrics:
+            metrics.record_operation('my_operation', 1)
+    """
+    global _global_metrics
+    
+    if _global_metrics is None:
+        logger.warning("Global metrics not initialized - call initialize_global_metrics() first")
+        return None
+    
+    return _global_metrics
+
+
+async def close_global_metrics():
+    """
+    Close the global metrics instance.
+    
+    This should be called during application shutdown.
+    """
+    global _global_metrics, _initialized
+    
+    if _global_metrics:
+        try:
+            # ExecutorMetrics doesn't have a close method, but we can clean up
+            logger.info("Closing global metrics...")
+            _global_metrics = None
+            _initialized = False
+            logger.info("✅ Global metrics closed successfully")
+        except Exception as e:
+            logger.error(f"❌ Error closing global metrics: {e}")
+
+
+def is_metrics_initialized() -> bool:
+    """
+    Check if global metrics are initialized.
+    
+    Returns:
+        True if metrics are initialized, False otherwise
+    """
+    return _initialized and _global_metrics is not None
+
+
+def get_metrics_summary() -> Dict[str, Any]:
+    """
+    Get a summary of the global metrics status.
+    
+    Returns:
+        Dictionary containing metrics status information
+    """
+    if not is_metrics_initialized():
+        return {
+            "initialized": False,
+            "message": "Global metrics not initialized"
+        }
+    
+    try:
+        return _global_metrics.get_metrics_summary()
+    except Exception as e:
+        return {
+            "initialized": True,
+            "error": str(e),
+            "message": "Failed to get metrics summary"
+        }
+
+
+# Convenience functions for common operations
+def record_operation(operation_type: str, success: bool = True, duration: Optional[float] = None, **kwargs):
+    """Record an operation using global metrics."""
+    metrics = get_global_metrics()
+    if metrics:
+        metrics.record_operation(operation_type, success, duration, **kwargs)
+
+
+def record_duration(operation: str, duration: float, labels: Optional[Dict[str, str]] = None):
+    """Record operation duration using global metrics."""
+    metrics = get_global_metrics()
+    if metrics:
+        metrics.record_duration(operation, duration, labels)
+
+
+def record_operation_success(operation: str, labels: Optional[Dict[str, str]] = None):
+    """Record operation success using global metrics."""
+    metrics = get_global_metrics()
+    if metrics:
+        metrics.record_operation_success(operation, labels)
+
+
+def record_operation_failure(operation: str, error_type: str, labels: Optional[Dict[str, str]] = None):
+    """Record operation failure using global metrics."""
+    metrics = get_global_metrics()
+    if metrics:
+        metrics.record_operation_failure(operation, error_type, labels)
+
+
+def record_retry(operation: str, attempt_number: int):
+    """Record retry using global metrics."""
+    metrics = get_global_metrics()
+    if metrics:
+        metrics.record_retry(operation, attempt_number)

{aiecs-1.2.0 → aiecs-1.2.2}/aiecs/infrastructure/persistence/file_storage.py

@@ -29,7 +29,7 @@ except ImportError:
     GoogleCloudError = Exception
     DefaultCredentialsError = Exception
 
-from ..monitoring.executor_metrics import ExecutorMetrics
+from ..monitoring.global_metrics_manager import get_global_metrics
 
 logger = logging.getLogger(__name__)
 
@@ -93,8 +93,8 @@ class FileStorage:
         self._cache_timestamps = {}
         self._initialized = False
 
-        # Metrics
-        self.metrics = ExecutorMetrics(enable_metrics=True)
+        # Metrics - use global metrics manager
+        self.metrics = get_global_metrics()
 
         # Ensure local storage directory exists
         if self.config.enable_local_fallback:
@@ -205,26 +205,30 @@ class FileStorage:
             if self._gcs_bucket:
                 success = await self._store_gcs(key, serialized_data, metadata, compressed)
                 if success:
-                    self.metrics.record_operation('gcs_store_success', 1)
-                    duration = (datetime.utcnow() - start_time).total_seconds()
-                    self.metrics.record_duration('gcs_store_duration', duration)
+                    if self.metrics:
+                        self.metrics.record_operation('gcs_store_success', 1)
+                        duration = (datetime.utcnow() - start_time).total_seconds()
+                        self.metrics.record_duration('gcs_store_duration', duration)
                     return True
 
             # Fallback to local storage
             if self.config.enable_local_fallback:
                 success = await self._store_local(key, serialized_data, metadata, compressed)
                 if success:
-                    self.metrics.record_operation('local_store_success', 1)
-                    duration = (datetime.utcnow() - start_time).total_seconds()
-                    self.metrics.record_duration('local_store_duration', duration)
+                    if self.metrics:
+                        self.metrics.record_operation('local_store_success', 1)
+                        duration = (datetime.utcnow() - start_time).total_seconds()
+                        self.metrics.record_duration('local_store_duration', duration)
                     return True
 
-            self.metrics.record_operation('store_failure', 1)
+            if self.metrics:
+                self.metrics.record_operation('store_failure', 1)
             return False
 
         except Exception as e:
             logger.error(f"Failed to store data for key {key}: {e}")
-            self.metrics.record_operation('store_error', 1)
+            if self.metrics:
+                self.metrics.record_operation('store_error', 1)
             raise FileStorageError(f"Storage failed: {e}")
 
     async def retrieve(self, key: str) -> Optional[Union[str, bytes, Dict[str, Any]]]:
@@ -247,7 +251,8 @@ class FileStorage:
             if self.config.enable_cache and key in self._cache:
                 cache_time = self._cache_timestamps.get(key)
                 if cache_time and (datetime.utcnow() - cache_time).total_seconds() < self.config.cache_ttl_seconds:
-                    self.metrics.record_operation('cache_hit', 1)
+                    if self.metrics:
+                        self.metrics.record_operation('cache_hit', 1)
                     return self._cache[key]['data']
                 else:
                     # Remove expired cache entry
@@ -258,9 +263,10 @@ class FileStorage:
             if self._gcs_bucket:
                 data = await self._retrieve_gcs(key)
                 if data is not None:
-                    self.metrics.record_operation('gcs_retrieve_success', 1)
-                    duration = (datetime.utcnow() - start_time).total_seconds()
-                    self.metrics.record_duration('gcs_retrieve_duration', duration)
+                    if self.metrics:
+                        self.metrics.record_operation('gcs_retrieve_success', 1)
+                        duration = (datetime.utcnow() - start_time).total_seconds()
+                        self.metrics.record_duration('gcs_retrieve_duration', duration)
 
                     # Update cache
                     if self.config.enable_cache:
@@ -273,9 +279,10 @@ class FileStorage:
             if self.config.enable_local_fallback:
                 data = await self._retrieve_local(key)
                 if data is not None:
-                    self.metrics.record_operation('local_retrieve_success', 1)
-                    duration = (datetime.utcnow() - start_time).total_seconds()
-                    self.metrics.record_duration('local_retrieve_duration', duration)
+                    if self.metrics:
+                        self.metrics.record_operation('local_retrieve_success', 1)
+                        duration = (datetime.utcnow() - start_time).total_seconds()
+                        self.metrics.record_duration('local_retrieve_duration', duration)
 
                     # Update cache
                     if self.config.enable_cache:
@@ -284,12 +291,14 @@ class FileStorage:
 
                     return data
 
-            self.metrics.record_operation('retrieve_not_found', 1)
+            if self.metrics:
+                self.metrics.record_operation('retrieve_not_found', 1)
             return None
 
         except Exception as e:
             logger.error(f"Failed to retrieve data for key {key}: {e}")
-            self.metrics.record_operation('retrieve_error', 1)
+            if self.metrics:
+                self.metrics.record_operation('retrieve_error', 1)
             raise FileStorageError(f"Retrieval failed: {e}")
 
     async def delete(self, key: str) -> bool:
@@ -317,7 +326,8 @@ class FileStorage:
             if self._gcs_bucket:
                 gcs_success = await self._delete_gcs(key)
                 if gcs_success:
-                    self.metrics.record_operation('gcs_delete_success', 1)
+                    if self.metrics:
+                        self.metrics.record_operation('gcs_delete_success', 1)
                 else:
                     success = False
 
@@ -325,20 +335,23 @@ class FileStorage:
             if self.config.enable_local_fallback:
                 local_success = await self._delete_local(key)
                 if local_success:
-                    self.metrics.record_operation('local_delete_success', 1)
+                    if self.metrics:
+                        self.metrics.record_operation('local_delete_success', 1)
                 else:
                     success = False
 
-            if success:
-                self.metrics.record_operation('delete_success', 1)
-            else:
-                self.metrics.record_operation('delete_failure', 1)
+            if self.metrics:
+                if success:
+                    self.metrics.record_operation('delete_success', 1)
+                else:
+                    self.metrics.record_operation('delete_failure', 1)
 
             return success
 
         except Exception as e:
             logger.error(f"Failed to delete data for key {key}: {e}")
-            self.metrics.record_operation('delete_error', 1)
+            if self.metrics:
+                self.metrics.record_operation('delete_error', 1)
             raise FileStorageError(f"Deletion failed: {e}")
 
     async def exists(self, key: str) -> bool:
@@ -646,7 +659,7 @@ class FileStorage:
             'local_fallback_enabled': self.config.enable_local_fallback,
             'cache_enabled': self.config.enable_cache,
             'cache_size': len(self._cache),
-            'metrics': self.metrics.get_metrics_summary() if hasattr(self.metrics, 'get_metrics_summary') else {}
+            'metrics': self.metrics.get_metrics_summary() if self.metrics and hasattr(self.metrics, 'get_metrics_summary') else {}
         }
 
 

aiecs-1.2.2/aiecs/llm/__init__.py

@@ -0,0 +1,93 @@
+"""
+LLM Package - Modular AI Provider Architecture
+
+This package provides a unified interface to multiple AI providers through
+individual client implementations and a factory pattern.
+
+Package Structure:
+- clients/: LLM client implementations
+- config/: Configuration management
+- callbacks/: Callback handlers
+- utils/: Utility functions and scripts
+"""
+
+# Import from organized subpackages
+from .clients import (
+    BaseLLMClient,
+    LLMMessage,
+    LLMResponse,
+    LLMClientError,
+    ProviderNotAvailableError,
+    RateLimitError,
+    OpenAIClient,
+    VertexAIClient,
+    GoogleAIClient,
+    XAIClient
+)
+
+from .client_factory import (
+    AIProvider,
+    LLMClientFactory,
+    LLMClientManager,
+    get_llm_manager,
+    generate_text,
+    stream_text
+)
+
+from .config import (
+    ModelCostConfig,
+    ModelCapabilities,
+    ModelDefaultParams,
+    ModelConfig,
+    ProviderConfig,
+    LLMModelsConfig,
+    LLMConfigLoader,
+    get_llm_config_loader,
+    get_llm_config,
+    reload_llm_config
+)
+
+from .callbacks import (
+    CustomAsyncCallbackHandler
+)
+
+__all__ = [
+    # Base classes and types
+    'BaseLLMClient',
+    'LLMMessage',
+    'LLMResponse',
+    'LLMClientError',
+    'ProviderNotAvailableError',
+    'RateLimitError',
+    'AIProvider',
+
+    # Factory and manager
+    'LLMClientFactory',
+    'LLMClientManager',
+    'get_llm_manager',
+
+    # Individual clients
+    'OpenAIClient',
+    'VertexAIClient',
+    'GoogleAIClient',
+    'XAIClient',
+
+    # Convenience functions
+    'generate_text',
+    'stream_text',
+    
+    # Configuration management
+    'ModelCostConfig',
+    'ModelCapabilities',
+    'ModelDefaultParams',
+    'ModelConfig',
+    'ProviderConfig',
+    'LLMModelsConfig',
+    'LLMConfigLoader',
+    'get_llm_config_loader',
+    'get_llm_config',
+    'reload_llm_config',
+    
+    # Callbacks
+    'CustomAsyncCallbackHandler',
+]

aiecs-1.2.2/aiecs/llm/callbacks/__init__.py

@@ -0,0 +1,12 @@
+"""
+LLM Callbacks.
+
+This package contains callback handlers for LLM operations.
+"""
+
+from .custom_callbacks import CustomAsyncCallbackHandler
+
+__all__ = [
+    "CustomAsyncCallbackHandler",
+]
+

{aiecs-1.2.0/aiecs/llm → aiecs-1.2.2/aiecs/llm/callbacks}/custom_callbacks.py

@@ -4,7 +4,7 @@ import logging
 # Import the base callback handler from utils
 from aiecs.utils.base_callback import CustomAsyncCallbackHandler
 # Import LLM types for internal use only
-from aiecs.llm.base_client import LLMMessage, LLMResponse
+from aiecs.llm.clients.base_client import LLMMessage, LLMResponse
 # Import token usage repository
 from aiecs.utils.token_usage_repository import token_usage_repo
 

{aiecs-1.2.0 → aiecs-1.2.2}/aiecs/llm/client_factory.py

@@ -2,12 +2,12 @@ import logging
 from typing import Dict, Any, Optional, Union, List
 from enum import Enum
 
-from .base_client import BaseLLMClient, LLMMessage, LLMResponse
-from .openai_client import OpenAIClient
-from .vertex_client import VertexAIClient
-from .googleai_client import GoogleAIClient
-from .xai_client import XAIClient
-from ..utils.base_callback import CustomAsyncCallbackHandler
+from .clients.base_client import BaseLLMClient, LLMMessage, LLMResponse
+from .clients.openai_client import OpenAIClient
+from .clients.vertex_client import VertexAIClient
+from .clients.googleai_client import GoogleAIClient
+from .clients.xai_client import XAIClient
+from .callbacks.custom_callbacks import CustomAsyncCallbackHandler
 
 logger = logging.getLogger(__name__)
 
@@ -72,6 +72,23 @@ class LLMClientFactory:
                 del cls._clients[provider]
             except Exception as e:
                 logger.error(f"Error closing client {provider}: {e}")
+    
+    @classmethod
+    def reload_config(cls):
+        """
+        Reload LLM models configuration.
+        
+        This reloads the configuration from the YAML file, allowing for
+        hot-reloading of model settings without restarting the application.
+        """
+        try:
+            from aiecs.llm.config import reload_llm_config
+            config = reload_llm_config()
+            logger.info(f"Reloaded LLM configuration: {len(config.providers)} providers")
+            return config
+        except Exception as e:
+            logger.error(f"Failed to reload LLM configuration: {e}")
+            raise
 
 class LLMClientManager:
     """High-level manager for LLM operations with context-aware provider selection"""