aiecs 1.0.5__py3-none-any.whl → 1.0.7__py3-none-any.whl

aiecs/infrastructure/persistence/context_engine_client.py

@@ -0,0 +1,176 @@
+"""
+Global ContextEngine Manager
+
+This module provides a singleton ContextEngine instance that can be shared
+across all components in the application. It follows the same pattern as
+the Redis client initialization in aiecs.infrastructure.persistence.redis_client.
+
+Usage:
+    # In main.py startup:
+    await initialize_context_engine()
+    
+    # In any component:
+    from aiecs.infrastructure.persistence.context_engine_client import get_context_engine
+    context_engine = get_context_engine()
+"""
+
+import logging
+from typing import Optional
+import asyncio
+
+logger = logging.getLogger(__name__)
+
+# Global singleton instance
+_global_context_engine: Optional['ContextEngine'] = None
+_initialization_lock = asyncio.Lock()
+_initialized = False
+
+try:
+    from aiecs.domain.context.context_engine import ContextEngine
+except ImportError:
+    ContextEngine = None
+    logger.warning("ContextEngine not available - aiecs package may not be installed")
+
+
+async def initialize_context_engine(use_existing_redis: bool = True) -> Optional['ContextEngine']:
+    """
+    Initialize the global ContextEngine instance.
+    
+    This should be called once during application startup (in main.py lifespan).
+    
+    Args:
+        use_existing_redis: Whether to use existing Redis client (default: True)
+        
+    Returns:
+        The initialized ContextEngine instance or None if initialization fails
+        
+    Example:
+        @asynccontextmanager
+        async def lifespan(app: FastAPI):
+            # Startup
+            await initialize_redis_client()
+            await initialize_context_engine()  # Initialize after Redis
+            yield
+            # Shutdown
+            await close_context_engine()
+            await close_redis_client()
+    """
+    global _global_context_engine, _initialized
+    
+    if _initialized and _global_context_engine:
+        logger.info("ContextEngine already initialized")
+        return _global_context_engine
+    
+    async with _initialization_lock:
+        # Double-check after acquiring lock
+        if _initialized and _global_context_engine:
+            return _global_context_engine
+        
+        if not ContextEngine:
+            logger.error("ContextEngine class not available - cannot initialize")
+            return None
+        
+        try:
+            logger.info("Initializing global ContextEngine...")
+            _global_context_engine = ContextEngine(use_existing_redis=use_existing_redis)
+            await _global_context_engine.initialize()
+            _initialized = True
+            logger.info("✅ Global ContextEngine initialized successfully")
+            return _global_context_engine
+            
+        except Exception as e:
+            logger.error(f"❌ Failed to initialize global ContextEngine: {e}")
+            logger.warning("Application will continue without ContextEngine (degraded mode)")
+            _global_context_engine = None
+            _initialized = False
+            return None
+
+
+def get_context_engine() -> Optional['ContextEngine']:
+    """
+    Get the global ContextEngine instance.
+    
+    Returns:
+        The global ContextEngine instance or None if not initialized
+        
+    Example:
+        from aiecs.infrastructure.persistence.context_engine_client import get_context_engine
+        
+        context_engine = get_context_engine()
+        if context_engine:
+            await context_engine.add_conversation_message(...)
+        else:
+            # Fallback to local storage
+            logger.warning("ContextEngine not available")
+    """
+    if not _initialized:
+        logger.warning(
+            "ContextEngine not initialized. Call initialize_context_engine() "
+            "during application startup."
+        )
+    return _global_context_engine
+
+
+async def close_context_engine() -> None:
+    """
+    Close and cleanup the global ContextEngine instance.
+    
+    This should be called during application shutdown (in main.py lifespan).
+    
+    Example:
+        @asynccontextmanager
+        async def lifespan(app: FastAPI):
+            # Startup
+            await initialize_context_engine()
+            yield
+            # Shutdown
+            await close_context_engine()
+    """
+    global _global_context_engine, _initialized
+    
+    async with _initialization_lock:
+        if _global_context_engine:
+            try:
+                logger.info("Closing global ContextEngine...")
+                # ContextEngine cleanup if needed
+                if hasattr(_global_context_engine, 'close'):
+                    await _global_context_engine.close()
+                logger.info("✅ Global ContextEngine closed successfully")
+            except Exception as e:
+                logger.error(f"Error closing ContextEngine: {e}")
+            finally:
+                _global_context_engine = None
+                _initialized = False
+
+
+def is_context_engine_initialized() -> bool:
+    """
+    Check if the global ContextEngine is initialized.
+    
+    Returns:
+        True if ContextEngine is initialized and available, False otherwise
+    """
+    return _initialized and _global_context_engine is not None
+
+
+# Convenience function for testing
+async def reset_context_engine() -> None:
+    """
+    Reset the global ContextEngine instance.
+    
+    This is primarily for testing purposes to allow re-initialization.
+    Should NOT be used in production code.
+    """
+    global _global_context_engine, _initialized
+    
+    async with _initialization_lock:
+        if _global_context_engine:
+            try:
+                if hasattr(_global_context_engine, 'close'):
+                    await _global_context_engine.close()
+            except Exception as e:
+                logger.warning(f"Error during ContextEngine reset: {e}")
+        
+        _global_context_engine = None
+        _initialized = False
+        logger.info("ContextEngine reset completed")

aiecs/llm/__init__.py

@@ -26,6 +26,7 @@ from .client_factory import (
 
 from .openai_client import OpenAIClient
 from .vertex_client import VertexAIClient
+from .googleai_client import GoogleAIClient
 from .xai_client import XAIClient
 
 __all__ = [
@@ -46,6 +47,7 @@ __all__ = [
     # Individual clients
     'OpenAIClient',
     'VertexAIClient',
+    'GoogleAIClient',
     'XAIClient',
 
     # Convenience functions

aiecs/llm/base_client.py

@@ -21,6 +21,7 @@ class LLMResponse:
     completion_tokens: Optional[int] = None
     cost_estimate: Optional[float] = None
     response_time: Optional[float] = None
+    metadata: Optional[Dict[str, Any]] = None  # Added for backward compatibility
 
     def __post_init__(self):
         """Ensure consistency of token data"""

aiecs/llm/client_factory.py

@@ -5,6 +5,7 @@ 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
 
@@ -13,6 +14,7 @@ logger = logging.getLogger(__name__)
 class AIProvider(str, Enum):
     OPENAI = "OpenAI"
     VERTEX = "Vertex"
+    GOOGLEAI = "GoogleAI"
     XAI = "xAI"
 
 class LLMClientFactory:
@@ -41,6 +43,8 @@ class LLMClientFactory:
             return OpenAIClient()
         elif provider == AIProvider.VERTEX:
             return VertexAIClient()
+        elif provider == AIProvider.GOOGLEAI:
+            return GoogleAIClient()
         elif provider == AIProvider.XAI:
             return XAIClient()
         else:

aiecs/llm/googleai_client.py

@@ -0,0 +1,165 @@
+import asyncio
+import logging
+import os
+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.config.config import get_settings
+
+logger = logging.getLogger(__name__)
+
+class GoogleAIClient(BaseLLMClient):
+    """Google AI (Gemini) provider client"""
+
+    def __init__(self):
+        super().__init__("GoogleAI")
+        self.settings = get_settings()
+        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:
+            api_key = self.settings.googleai_api_key or os.environ.get("GOOGLEAI_API_KEY")
+            if not api_key:
+                raise ProviderNotAvailableError("Google AI API key not configured. Set GOOGLEAI_API_KEY.")
+
+            try:
+                genai.configure(api_key=api_key)
+                self._initialized = True
+                self.logger.info("Google AI SDK initialized successfully.")
+            except Exception as e:
+                raise ProviderNotAvailableError(f"Failed to initialize Google AI SDK: {str(e)}")
+
+    async def generate_text(
+        self,
+        messages: List[LLMMessage],
+        model: Optional[str] = None,
+        temperature: float = 0.7,
+        max_tokens: Optional[int] = None,
+        **kwargs
+    ) -> LLMResponse:
+        """Generate text using Google AI"""
+        self._init_google_ai()
+        model_name = model or "gemini-2.5-pro"
+
+        try:
+            model_instance = genai.GenerativeModel(model_name)
+            
+            # Convert messages to Google AI format
+            history = [{"role": msg.role, "parts": [msg.content]} for msg in messages]
+
+            # The last message is the prompt
+            prompt = history.pop()
+            
+            # Create GenerationConfig
+            generation_config = GenerationConfig(
+                temperature=temperature,
+                max_output_tokens=max_tokens or 8192,
+                top_p=kwargs.get("top_p", 0.95),
+                top_k=kwargs.get("top_k", 40)
+            )
+
+            # Safety settings to match vertex_client
+            safety_settings = {
+                HarmCategory.HARM_CATEGORY_HARASSMENT: HarmBlockThreshold.BLOCK_NONE,
+                HarmCategory.HARM_CATEGORY_HATE_SPEECH: HarmBlockThreshold.BLOCK_NONE,
+                HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT: HarmBlockThreshold.BLOCK_NONE,
+                HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT: HarmBlockThreshold.BLOCK_NONE,
+            }
+
+            response = await model_instance.generate_content_async(
+                contents=prompt['parts'],
+                generation_config=generation_config,
+                safety_settings=safety_settings
+            )
+
+            content = response.text
+            prompt_tokens = response.usage_metadata.prompt_token_count
+            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
+            )
+
+            return LLMResponse(
+                content=content,
+                provider=self.provider_name,
+                model=model_name,
+                tokens_used=total_tokens,
+                prompt_tokens=prompt_tokens,
+                completion_tokens=completion_tokens,
+                cost_estimate=cost
+            )
+
+        except Exception as e:
+            if "quota" in str(e).lower():
+                raise RateLimitError(f"Google AI quota exceeded: {str(e)}")
+            self.logger.error(f"Error generating text with Google AI: {e}")
+            raise
+
+    async def stream_text(
+        self,
+        messages: List[LLMMessage],
+        model: Optional[str] = None,
+        temperature: float = 0.7,
+        max_tokens: Optional[int] = None,
+        **kwargs
+    ) -> AsyncGenerator[str, None]:
+        """Stream text generation using Google AI"""
+        self._init_google_ai()
+        model_name = model or "gemini-2.5-pro"
+
+        try:
+            model_instance = genai.GenerativeModel(model_name)
+            
+            # Convert messages to Google AI format
+            history = [{"role": msg.role, "parts": [msg.content]} for msg in messages]
+            prompt = history.pop()
+
+            generation_config = GenerationConfig(
+                temperature=temperature,
+                max_output_tokens=max_tokens or 8192,
+                top_p=kwargs.get("top_p", 0.95),
+                top_k=kwargs.get("top_k", 40)
+            )
+            
+            safety_settings = {
+                HarmCategory.HARM_CATEGORY_HARASSMENT: HarmBlockThreshold.BLOCK_NONE,
+                HarmCategory.HARM_CATEGORY_HATE_SPEECH: HarmBlockThreshold.BLOCK_NONE,
+                HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT: HarmBlockThreshold.BLOCK_NONE,
+                HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT: HarmBlockThreshold.BLOCK_NONE,
+            }
+
+            response_stream = await model_instance.generate_content_async(
+                contents=prompt['parts'],
+                generation_config=generation_config,
+                safety_settings=safety_settings,
+                stream=True
+            )
+
+            async for chunk in response_stream:
+                if chunk.text:
+                    yield chunk.text
+
+        except Exception as e:
+            self.logger.error(f"Error streaming text with Google AI: {e}")
+            raise
+
+    async def close(self):
+        """Clean up resources"""
+        # Google AI SDK does not require explicit closing of a client
+        self._initialized = False

aiecs/llm/vertex_client.py

@@ -2,8 +2,8 @@ import asyncio
 import logging
 import os
 from typing import Dict, Any, Optional, List, AsyncGenerator
-from vertexai.generative_models import GenerativeModel, HarmCategory, HarmBlockThreshold
 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
@@ -76,6 +76,7 @@ class VertexAIClient(BaseLLMClient):
         try:
             # Use the stable Vertex AI API
             model_instance = GenerativeModel(model_name)
+            self.logger.debug(f"Initialized Vertex AI model: {model_name}")
 
             # Convert messages to Vertex AI format
             if len(messages) == 1 and messages[0].role == "user":
@@ -84,50 +85,82 @@ class VertexAIClient(BaseLLMClient):
                 # For multi-turn conversations, combine messages
                 prompt = "\n".join([f"{msg.role}: {msg.content}" for msg in messages])
 
+            # Use modern GenerationConfig object
+            generation_config = GenerationConfig(
+                temperature=temperature,
+                max_output_tokens=max_tokens or 8192,  # Increased to account for thinking tokens
+                top_p=0.95,
+                top_k=40,
+            )
+
+            # Modern safety settings configuration using SafetySetting objects
+            safety_settings = [
+                SafetySetting(category=HarmCategory.HARM_CATEGORY_HARASSMENT, threshold=HarmBlockThreshold.BLOCK_NONE),
+                SafetySetting(category=HarmCategory.HARM_CATEGORY_HATE_SPEECH, threshold=HarmBlockThreshold.BLOCK_NONE),
+                SafetySetting(category=HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT, threshold=HarmBlockThreshold.BLOCK_NONE),
+                SafetySetting(category=HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT, threshold=HarmBlockThreshold.BLOCK_NONE),
+            ]
+
             response = await asyncio.get_event_loop().run_in_executor(
                 None,
                 lambda: model_instance.generate_content(
                     prompt,
-                    generation_config={
-                        "temperature": temperature,
-                        "max_output_tokens": max_tokens or 8192,  # Increased to account for thinking tokens
-                        "top_p": 0.95,
-                        "top_k": 40,
-                    },
-                    safety_settings={
-                        HarmCategory.HARM_CATEGORY_HARASSMENT: HarmBlockThreshold.BLOCK_NONE,
-                        HarmCategory.HARM_CATEGORY_HATE_SPEECH: HarmBlockThreshold.BLOCK_NONE,
-                        HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT: HarmBlockThreshold.BLOCK_NONE,
-                        HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT: HarmBlockThreshold.BLOCK_NONE,
-                    }
+                    generation_config=generation_config,
+                    safety_settings=safety_settings
                 )
             )
 
-            # Handle response content safely
+            # Handle response content safely - improved multi-part response handling
+            content = None
             try:
+                # First try to get text directly
                 content = response.text
                 self.logger.debug(f"Vertex AI response received: {content[:100]}...")
-            except ValueError as ve:
-                # Handle cases where response has no content (safety filters, etc.)
-                self.logger.warning(f"Vertex AI response error: {str(ve)}")
-                self.logger.debug(f"Full response object: {response}")
-
-                # Check if response has candidates but no text
+            except (ValueError, AttributeError) as ve:
+                # Handle multi-part responses and other issues
+                self.logger.warning(f"Cannot get response text directly: {str(ve)}")
+                
+                # Try to extract content from candidates with multi-part support
                 if hasattr(response, 'candidates') and response.candidates:
                     candidate = response.candidates[0]
                     self.logger.debug(f"Candidate finish_reason: {getattr(candidate, 'finish_reason', 'unknown')}")
-
-                    # If finish_reason is MAX_TOKENS, it might be due to thinking tokens
-                    if hasattr(candidate, 'finish_reason') and candidate.finish_reason == 'MAX_TOKENS':
-                        content = "[Response truncated due to token limit - consider increasing max_tokens for Gemini 2.5 models]"
-                        self.logger.warning("Response truncated due to MAX_TOKENS - Gemini 2.5 uses thinking tokens")
-                    elif "no parts" in str(ve).lower() or "safety filters" in str(ve).lower():
-                        content = "[Response blocked by safety filters or has no content]"
-                        self.logger.warning(f"Vertex AI response blocked or empty: {str(ve)}")
-                    else:
-                        content = f"[Response error: {str(ve)}]"
+                    
+                    # Handle multi-part content
+                    if hasattr(candidate, 'content') and hasattr(candidate.content, 'parts'):
+                        try:
+                            # Extract text from all parts
+                            text_parts = []
+                            for part in candidate.content.parts:
+                                if hasattr(part, 'text') and part.text:
+                                    text_parts.append(part.text)
+                            
+                            if text_parts:
+                                content = "\n".join(text_parts)
+                                self.logger.info(f"Successfully extracted multi-part response: {len(text_parts)} parts")
+                            else:
+                                self.logger.warning("No text content found in multi-part response")
+                        except Exception as part_error:
+                            self.logger.error(f"Failed to extract content from multi-part response: {str(part_error)}")
+                    
+                    # If still no content, check finish reason
+                    if not content:
+                        if hasattr(candidate, 'finish_reason'):
+                            if candidate.finish_reason == 'MAX_TOKENS':
+                                content = "[Response truncated due to token limit - consider increasing max_tokens for Gemini 2.5 models]"
+                                self.logger.warning("Response truncated due to MAX_TOKENS - Gemini 2.5 uses thinking tokens")
+                            elif candidate.finish_reason in ['SAFETY', 'RECITATION']:
+                                content = "[Response blocked by safety filters or content policy]"
+                                self.logger.warning(f"Response blocked by safety filters: {candidate.finish_reason}")
+                            else:
+                                content = f"[Response error: Cannot get response text - {candidate.finish_reason}]"
+                        else:
+                            content = "[Response error: Cannot get the response text]"
                 else:
-                    content = f"[Response error: {str(ve)}]"
+                    content = f"[Response error: No candidates found - {str(ve)}]"
+                
+                # Final fallback
+                if not content:
+                    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)
@@ -150,11 +183,16 @@ class VertexAIClient(BaseLLMClient):
             if "quota" in str(e).lower() or "limit" in str(e).lower():
                 raise RateLimitError(f"Vertex AI quota exceeded: {str(e)}")
             # Handle specific Vertex AI response errors
-            if "cannot get the response text" in str(e).lower() or "safety filters" in str(e).lower():
+            if any(keyword in str(e).lower() for keyword in [
+                "cannot get the response text",
+                "safety filters", 
+                "multiple content parts are not supported",
+                "cannot get the candidate text"
+            ]):
                 self.logger.warning(f"Vertex AI response issue: {str(e)}")
                 # Return a response indicating the issue
                 return LLMResponse(
-                    content="[Response unavailable due to safety filters or content policy]",
+                    content="[Response unavailable due to content processing issues or safety filters]",
                     provider=self.provider_name,
                     model=model_name,
                     tokens_used=self._count_tokens_estimate(prompt),

aiecs/main.py

@@ -131,7 +131,7 @@ async def health_check():
     return {
         "status": "healthy",
         "service": "aiecs",
-        "version": "1.0.0"
+        "version": "1.0.7"
     }
 
 

{aiecs-1.0.5.dist-info → aiecs-1.0.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aiecs
-Version: 1.0.5
+Version: 1.0.7
 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
@@ -37,7 +37,8 @@ Requires-Dist: python-engineio<5.0.0,>=4.12.1
 Requires-Dist: tenacity<10.0.0,>=9.1.2
 Requires-Dist: flower<3.0.0,>=2.0.1
 Requires-Dist: openai<1.76.0,>=1.68.2
-Requires-Dist: google-cloud-aiplatform<2.0.0,>=1.71.1
+Requires-Dist: google-cloud-aiplatform<2.0.0,>=1.80.0
+Requires-Dist: google-generativeai<1.0.0,>=0.8.0
 Requires-Dist: langchain<0.4.0,>=0.3.26
 Requires-Dist: langgraph<0.6.0,>=0.5.3
 Requires-Dist: weasel==0.4.1

{aiecs-1.0.5.dist-info → aiecs-1.0.7.dist-info}/RECORD

@@ -1,18 +1,24 @@
-aiecs/__init__.py,sha256=_hZLs48lP9j2hr3Wdf2KYKIED9YMWtDD7s-SSfyslgs,1859
+aiecs/__init__.py,sha256=AWE44N5Mrei5upCp4_F1Qunc9mkcD42vvqtf48d5VCw,1859
 aiecs/__main__.py,sha256=AfQpzy3SgwWuP4DuymYcm4MISMuzqwhxxGSYo53PBvY,1035
 aiecs/aiecs_client.py,sha256=gJbCY6zuHR9TZPCgHhxd-d4CwCW9P_lUrtTSC5-ADWE,10527
-aiecs/main.py,sha256=3ThBIeGWw-tIZguWd9HMSlFEcTOQeiFFlWBGq1INKY4,9306
+aiecs/main.py,sha256=dzXOz3feZEwSEOJse4ZqGHRkoNjQoUh6htj4y460oVw,9306
 aiecs/application/__init__.py,sha256=NkmrUH1DqxJ3vaVC8QwscNdlWqHfC7ZagL4k3nZ_qz4,192
 aiecs/application/executors/__init__.py,sha256=WIl7L9HBsEhNfbNtJdvBvFUJXzESvNZVaiAA6tdtJcs,191
 aiecs/application/executors/operation_executor.py,sha256=-7mFo1hUnWdehVPg0fnSiRhW3LACpIiyLSH-iu7bX4U,13818
 aiecs/config/__init__.py,sha256=HykU6FgZrUx0w8V1_kAjP9NpXZTddZ9M3xo0fmBwMU8,336
-aiecs/config/config.py,sha256=vWkbWpRLxkRDdsl8hwgNpTKdvOhlxXiNh7oLQZBse-U,4993
+aiecs/config/config.py,sha256=L37G1xOQggnuHgYp9uOvbFsGlXI3JzHgZZ8mZpQVyGo,5065
 aiecs/config/registry.py,sha256=5CPJcjeMu3FLc_keuCtJT60DtUxF6w-I68uIoxpcdq8,637
 aiecs/core/__init__.py,sha256=H0ZIk96q0KHKivcobnUCVJdJZmewucVJ9MKhRgUxmk0,1037
 aiecs/core/interface/__init__.py,sha256=soI7zdoN3eQynVb9uiwmgXkM5E75JYffTILktHb48x8,688
 aiecs/core/interface/execution_interface.py,sha256=6bXruts8dyAg647lxPDQkF-cdJG1W8ZqpxFQ6hjVrd4,4810
 aiecs/core/interface/storage_interface.py,sha256=F7GQEZ_ZiRWeen7oZO6A4S0nW0VORYsygk2BYLw5aiY,5680
 aiecs/domain/__init__.py,sha256=fwcoCiZxcRmXPhRUEiYVYdY9QAB29Dmst1oPJC9jYvU,875
+aiecs/domain/community/collaborative_workflow.py,sha256=XheSSBzEOQM9bT1cPd2CJD9q-ORNe-oMedVGEnM1teM,15441
+aiecs/domain/community/community_integration.py,sha256=Xy4bRy7S4IqIHl2sWIclb_k8ZqAhAs8nnAxdxQnYE7s,16219
+aiecs/domain/community/community_manager.py,sha256=D-HrQTXO-uu9MK6Utr9aCVlQug0UAJc3eYamecQZulc,12119
+aiecs/domain/community/decision_engine.py,sha256=QZnSo0KxHk8HclUiB2sTYUI-H26ZI48StYXVIssO5kA,13389
+aiecs/domain/community/resource_manager.py,sha256=REWe6dSzxzWIxW-Xu07k3n8wSGfTw4frPWSfEW50t70,15912
+aiecs/domain/community/models/community_models.py,sha256=75h8lb1LmOVfpAw5Eh4_2djbSZkcvccKT_Ke1Xx573E,10094
 aiecs/domain/context/__init__.py,sha256=FfKatEwU5-REwBNdVRtWUXYqhdAFD2O4sKafnS5sG8M,864
 aiecs/domain/context/context_engine.py,sha256=HiUMAsUYx9ts242JzPZ0nJ9YjOYNpTnBY2lFI5RQ2FI,36439
 aiecs/domain/context/conversation_models.py,sha256=GgHEZTnHs6U-ecfAJ-0GJUXF48AdXCw0O8Lb8BzQ3oU,13005
@@ -30,16 +36,18 @@ aiecs/infrastructure/monitoring/__init__.py,sha256=fQ13Q1MTIJTNlh35BSCqXpayCTM_k
 aiecs/infrastructure/monitoring/executor_metrics.py,sha256=z8KJpq6tfCOEArfR-YJ4UClTsef2mNMFuSDHrP51Aww,6040
 aiecs/infrastructure/monitoring/structured_logger.py,sha256=iI895YHmPoaLdXjxHxd952PeTfGw6sh-yUDCnF8R7NY,1657
 aiecs/infrastructure/monitoring/tracing_manager.py,sha256=g4u6paNCZCYdGDEMZiv4bYv_GTG0s8oug-BJgFmkDp0,13449
-aiecs/infrastructure/persistence/__init__.py,sha256=7M0Z58QsSC6PJlZoLfBEiYQJh6t62P5QtwjiqBU0rEs,238
+aiecs/infrastructure/persistence/__init__.py,sha256=yoog7fEHmhgY50vGdgDNqiZCPUUL2-xnJrdhT5PrPWU,570
+aiecs/infrastructure/persistence/context_engine_client.py,sha256=CCVjNU4B3SeXdSLVpzV5hnsJilcF-AYdMzGmU0Bcwuo,5880
 aiecs/infrastructure/persistence/database_manager.py,sha256=MRkMTALeeybzAfnfuJrOXbEchBCrMAgsz8YYyEUVMjI,12592
 aiecs/infrastructure/persistence/file_storage.py,sha256=d3tcV7Wg_-TGsbw3PY9ttNANntR5rIo7mBgE0CGXKZQ,23321
 aiecs/infrastructure/persistence/redis_client.py,sha256=CqPtYFP8-KHl3cJG9VHun9YFFSp3kCc3ZaZbW7GlqUU,5791
-aiecs/llm/__init__.py,sha256=EsOIu25eDnhEYKZDb1h_O9RxYIF7vaiORUZSUipzhsM,1084
-aiecs/llm/base_client.py,sha256=xjirSGpLSsiWEhiTbKEFHNqbZanwJxBji9yVxegu77w,3193
-aiecs/llm/client_factory.py,sha256=Ysa3NYJIwgqBfFomTfG-G8z3cIElLPcv_vFM4D1IyCc,13566
+aiecs/llm/__init__.py,sha256=INfMR-xeQ0K53iXf_LRMVdo-hDXooIoAcmXRemLWmjQ,1150
+aiecs/llm/base_client.py,sha256=R4B-KBJ0aCEuvni5XwHd6sR3XNYQF3q1ZycgQvCJUfk,3275
+aiecs/llm/client_factory.py,sha256=qvQXo0kIcGC6SzIE7xfCN0f7CcGNKPwauFq2mTUP0SA,13718
 aiecs/llm/custom_callbacks.py,sha256=qwNwWqBl8EYj2aY16zXChZKLpxZahU9QeY4p57uZ5YU,9933
+aiecs/llm/googleai_client.py,sha256=4cJuhdzzn-svM7NLnYASYsnV2P758EeD5_ljVZu_XFc,6213
 aiecs/llm/openai_client.py,sha256=T3-LMDV-bzv0fwyDCw6h9D2XbNbWd0dt-QmjKg-wkd0,4397
-aiecs/llm/vertex_client.py,sha256=VN474c9fTUI2KpHOYlKJ8yQgd_VPQ7ht3dTtT7DoyWM,8601
+aiecs/llm/vertex_client.py,sha256=DSKyTwlhpOVTXfCTgTD7NholVFtVm7F5qmHk8p8X1Po,10823
 aiecs/llm/xai_client.py,sha256=VYfBGD8ns6NHscT68DDmAmvwBMEVykLQufH8kFNf_L8,6809
 aiecs/scripts/DEPENDENCY_SYSTEM_SUMMARY.md,sha256=u2OLwmXaRGuTwEfj3jQ_yzAO_Z49P1CBC1pV3iULuoE,5866
 aiecs/scripts/README_DEPENDENCY_CHECKER.md,sha256=7sAyeiMN7I-RsTOudo_JO2CTbC5ObEV0z_YyGtjiMcI,6003
@@ -82,9 +90,9 @@ aiecs/utils/prompt_loader.py,sha256=cBS2bZXpYQOWSiOGkhwIzyy3_bETqwIblRi_9qQT9iQ,
 aiecs/utils/token_usage_repository.py,sha256=1xjenLYwC0YT6lKZFEGO4scRCXLuWdec2MWjzih5SZY,10210
 aiecs/ws/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 aiecs/ws/socket_server.py,sha256=j_9idVY_rWlTsF51FgmuhWCWFVt7_gAHL8vNg3IxV5g,1476
-aiecs-1.0.5.dist-info/licenses/LICENSE,sha256=_1YRaIS0eZu1pv6xfz245UkU0i1Va2B841hv3OWRwqg,12494
-aiecs-1.0.5.dist-info/METADATA,sha256=_xt9zCfqZG6dafoVqRcmtYBdLEgjXlPh5na8qdTokU4,16388
-aiecs-1.0.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-aiecs-1.0.5.dist-info/entry_points.txt,sha256=0Bj2pSaZM-ADKTktbCQ0KQxRe0s8mQFKVsg3IGDJGqA,342
-aiecs-1.0.5.dist-info/top_level.txt,sha256=22IlUlOqh9Ni3jXlQNMNUqzbW8dcxXPeR_EQ-BJVcV8,6
-aiecs-1.0.5.dist-info/RECORD,,
+aiecs-1.0.7.dist-info/licenses/LICENSE,sha256=_1YRaIS0eZu1pv6xfz245UkU0i1Va2B841hv3OWRwqg,12494
+aiecs-1.0.7.dist-info/METADATA,sha256=ha9q-TJYdEZbuEYr4QIZGA_6m5alcDLmvWRNYQCw2NA,16437
+aiecs-1.0.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+aiecs-1.0.7.dist-info/entry_points.txt,sha256=0Bj2pSaZM-ADKTktbCQ0KQxRe0s8mQFKVsg3IGDJGqA,342
+aiecs-1.0.7.dist-info/top_level.txt,sha256=22IlUlOqh9Ni3jXlQNMNUqzbW8dcxXPeR_EQ-BJVcV8,6
+aiecs-1.0.7.dist-info/RECORD,,