aiecs 1.0.8__tar.gz → 1.1.1__tar.gz

{aiecs-1.0.8/aiecs.egg-info → aiecs-1.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aiecs
-Version: 1.0.8
+Version: 1.1.1
 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.0.8 → aiecs-1.1.1}/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.0.8"
+__version__ = "1.1.1"
 __author__ = "AIECS Team"
 __email__ = "iretbl@gmail.com"
 

{aiecs-1.0.8 → aiecs-1.1.1}/aiecs/aiecs_client.py

@@ -11,7 +11,8 @@ from contextlib import asynccontextmanager
 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
+from aiecs.llm.client_factory import LLMClientFactory, LLMClientManager, AIProvider
+from aiecs.llm.base_client import LLMMessage
 
 logger = logging.getLogger(__name__)
 
@@ -46,6 +47,7 @@ class AIECS:
         self.db_manager = None
         self.task_manager = None
         self.operation_executor = None
+        self.llm_manager = None
         
         # State
         self._initialized = False
@@ -65,6 +67,10 @@ class AIECS:
                 self._tools_discovered = True
                 logger.info("Tools discovered and registered")
             
+            # Initialize LLM manager (available in both modes)
+            self.llm_manager = LLMClientManager()
+            logger.info("LLM manager initialized")
+            
             if self.mode == "simple":
                 # Simple mode: only tools, no database/Celery
                 logger.info("Simple mode: tools only")
@@ -210,6 +216,158 @@ class AIECS:
         
         return get_tool(tool_name)
     
+    def process_task(self, task_context: TaskContext) -> Dict[str, Any]:
+        """
+        Process a task synchronously (for compatibility with synchronous tool calls)
+        
+        Args:
+            task_context: TaskContext containing the task data
+            
+        Returns:
+            Task processing result with AI-generated response
+        """
+        # Run the async method in a new event loop if needed
+        try:
+            loop = asyncio.get_event_loop()
+            if loop.is_running():
+                # If called from async context, create a new thread
+                import concurrent.futures
+                with concurrent.futures.ThreadPoolExecutor() as executor:
+                    future = executor.submit(
+                        asyncio.run,
+                        self.process_task_async(task_context)
+                    )
+                    return future.result()
+            else:
+                # Run in current event loop
+                return loop.run_until_complete(self.process_task_async(task_context))
+        except RuntimeError:
+            # No event loop, create one
+            return asyncio.run(self.process_task_async(task_context))
+    
+    async def process_task_async(self, task_context: TaskContext) -> Dict[str, Any]:
+        """
+        Process a task asynchronously using AI providers
+        
+        Args:
+            task_context: TaskContext containing the task data
+            
+        Returns:
+            Task processing result with AI-generated response
+        """
+        if not self._initialized:
+            await self.initialize()
+        
+        if not self.llm_manager:
+            raise RuntimeError("LLM manager not initialized")
+        
+        try:
+            # Extract data from TaskContext
+            context_dict = task_context.to_dict()
+            metadata = context_dict.get("metadata", {})
+            
+            # Get AI provider preference from metadata
+            ai_preference = metadata.get("aiPreference", "default")
+            provider = None
+            model = None
+            
+            # Parse AI preference
+            if isinstance(ai_preference, str):
+                # Simple string preference
+                if ai_preference.lower() != "default":
+                    try:
+                        provider = AIProvider(ai_preference)
+                    except ValueError:
+                        logger.warning(f"Unknown AI provider: {ai_preference}, using default")
+            elif isinstance(ai_preference, dict):
+                # Dictionary with provider and model
+                provider_str = ai_preference.get("provider")
+                if provider_str:
+                    try:
+                        provider = AIProvider(provider_str)
+                    except ValueError:
+                        logger.warning(f"Unknown AI provider: {provider_str}, using default")
+                model = ai_preference.get("model")
+            
+            # Build prompt from context data
+            # The prompt could come from various sources in the context
+            prompt = None
+            
+            # Check for direct prompt in metadata
+            if "prompt" in metadata:
+                prompt = metadata["prompt"]
+            # Check for input_data (common in document generation)
+            elif "input_data" in context_dict:
+                input_data = context_dict["input_data"]
+                if isinstance(input_data, dict) and "prompt" in input_data:
+                    prompt = input_data["prompt"]
+                elif isinstance(input_data, str):
+                    prompt = input_data
+            
+            if not prompt:
+                # Fallback: construct a simple prompt from available data
+                prompt = f"Task: {context_dict.get('task_type', 'general')}\nData: {context_dict}"
+            
+            # Get temperature and other parameters from metadata
+            temperature = metadata.get("temperature", 0.7)
+            max_tokens = metadata.get("max_tokens", 2000)
+            
+            # Generate text using LLM manager
+            messages = [LLMMessage(role="user", content=prompt)]
+            
+            response = await self.llm_manager.generate_text(
+                messages=messages,
+                provider=provider,
+                model=model,
+                context=context_dict,
+                temperature=temperature,
+                max_tokens=max_tokens
+            )
+            
+            # Track model usage in context
+            if hasattr(task_context, 'track_model_usage'):
+                task_context.track_model_usage(
+                    model_id=response.model,
+                    provider_id=response.provider,
+                    mode="generate"
+                )
+            
+            # Return result in expected format
+            return {
+                "status": "completed",
+                "response": response.content,
+                "provider": response.provider,
+                "model": response.model,
+                "tokens_used": response.tokens_used,
+                "cost_estimate": response.cost_estimate,
+                "context_id": context_dict.get("chat_id", "unknown")
+            }
+            
+        except Exception as e:
+            logger.error(f"Task processing failed: {e}", exc_info=True)
+            
+            # For testing/development, provide a mock response when AI provider is unavailable
+            error_str = str(e).lower()
+            if "api key not configured" in error_str or "providernotavailable" in error_str:
+                logger.warning("AI provider unavailable, using mock response for testing")
+                mock_content = f"Mock AI-generated content for prompt: {prompt[:100] if len(prompt) > 100 else prompt}..."
+                return {
+                    "status": "completed",
+                    "response": mock_content,
+                    "provider": "mock",
+                    "model": "mock-model",
+                    "tokens_used": len(mock_content.split()),
+                    "cost_estimate": 0.0,
+                    "context_id": context_dict.get("chat_id", "unknown"),
+                    "mock": True
+                }
+            
+            return {
+                "status": "failed",
+                "error": str(e),
+                "context_id": task_context.chat_id if hasattr(task_context, 'chat_id') else "unknown"
+            }
+    
     async def _wait_for_task_completion(self, task_id: str, timeout: int = 300) -> Dict[str, Any]:
         """
         Wait for task completion with timeout

{aiecs-1.0.8 → aiecs-1.1.1}/aiecs/config/config.py

@@ -40,6 +40,10 @@ class Settings(BaseSettings):
     # Vector store backend selection (Qdrant deprecated, using Vertex AI by default)
     vector_store_backend: str = Field("vertex", alias="VECTOR_STORE_BACKEND")  # "vertex" (qdrant deprecated)
 
+    # Development/Server Configuration
+    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")
 
     @property

aiecs-1.1.1/aiecs/domain/context/__init__.py

@@ -0,0 +1,53 @@
+"""
+Context Management Domain
+
+This module provides advanced context and session management capabilities
+for the Python middleware application.
+
+Components:
+- ContextEngine: Advanced context and session management with Redis backend
+- Integration with TaskContext for enhanced functionality
+- Support for BaseServiceCheckpointer and LangGraph workflows
+
+Usage:
+    # For creating ContextEngine instances directly:
+    from aiecs.domain.context import ContextEngine
+    engine = ContextEngine(use_existing_redis=True)
+    await engine.initialize()
+    
+    # For using the global singleton instance (recommended):
+    from aiecs.infrastructure.persistence import (
+        get_context_engine,
+        initialize_context_engine,
+        close_context_engine
+    )
+    
+    # The global instance is automatically initialized in main.py lifespan
+    context_engine = get_context_engine()
+    if context_engine:
+        await context_engine.add_conversation_message(...)
+
+Architecture Note:
+    - This package contains DOMAIN layer classes (business logic)
+    - Global instance management is in INFRASTRUCTURE layer:
+      aiecs.infrastructure.persistence.context_engine_client
+    - This separation follows Clean Architecture / DDD principles
+"""
+
+from .context_engine import ContextEngine, SessionMetrics, ConversationMessage
+from .conversation_models import (
+    ConversationParticipant, ConversationSession, AgentCommunicationMessage,
+    create_session_key, validate_conversation_isolation_pattern
+)
+
+__all__ = [
+    'ContextEngine',
+    'SessionMetrics',
+    'ConversationMessage',
+    'ConversationParticipant',
+    'ConversationSession',
+    'AgentCommunicationMessage',
+    'create_session_key',
+    'validate_conversation_isolation_pattern'
+]
+

{aiecs-1.0.8 → aiecs-1.1.1}/aiecs/main.py

@@ -23,6 +23,10 @@ from aiecs.ws.socket_server import sio
 
 # Import infrastructure
 from aiecs.infrastructure.persistence.database_manager import DatabaseManager
+from aiecs.infrastructure.persistence import (
+    initialize_context_engine,
+    close_context_engine
+)
 from aiecs.infrastructure.messaging.celery_task_manager import CeleryTaskManager
 from aiecs.infrastructure.monitoring.structured_logger import setup_structured_logging
 
@@ -82,6 +86,13 @@ async def lifespan(app: FastAPI):
         logger.error(f"Failed to discover tools: {e}")
         raise
     
+    # Initialize ContextEngine (optional, graceful degradation)
+    try:
+        await initialize_context_engine()
+        logger.info("ContextEngine initialized")
+    except Exception as e:
+        logger.warning(f"ContextEngine initialization failed (continuing without it): {e}")
+    
     # Application startup complete
     logger.info("AIECS startup complete")
     
@@ -90,6 +101,13 @@ async def lifespan(app: FastAPI):
     # Shutdown
     logger.info("Shutting down AIECS...")
     
+    # Close ContextEngine
+    try:
+        await close_context_engine()
+        logger.info("ContextEngine closed")
+    except Exception as e:
+        logger.warning(f"Error closing ContextEngine: {e}")
+    
     # Close database connection
     if db_manager:
         await db_manager.disconnect()
@@ -106,7 +124,7 @@ async def lifespan(app: FastAPI):
 app = FastAPI(
     title="AIECS - AI Execute Services",
     description="Middleware service for AI-powered task execution and tool orchestration",
-    version="1.0.5",
+    version="1.1.1",    
     lifespan=lifespan
 )
 
@@ -131,7 +149,7 @@ async def health_check():
     return {
         "status": "healthy",
         "service": "aiecs",
-        "version": "1.0.8"
+        "version": "1.1.1"
     }
 
 

aiecs-1.1.1/aiecs/scripts/aid/VERSION_MANAGEMENT.md

@@ -0,0 +1,97 @@
+# AIECS 版本管理
+
+AIECS 提供了一个统一的版本管理工具，可以同时更新项目中所有相关文件的版本号。
+
+## 支持的文件
+
+版本管理工具会自动更新以下文件中的版本号：
+
+1. **`aiecs/__init__.py`** - 更新 `__version__` 变量
+2. **`aiecs/main.py`** - 更新 FastAPI 应用版本和健康检查端点版本
+3. **`pyproject.toml`** - 更新项目版本
+
+## 使用方法
+
+### 1. 显示当前版本
+
+```bash
+poetry run python -m aiecs.scripts.aid.version_manager --show
+```
+
+### 2. 设置特定版本
+
+```bash
+poetry run python -m aiecs.scripts.aid.version_manager --version 1.2.0
+```
+
+### 3. 自动递增版本
+
+#### 补丁版本 (Patch)
+```bash
+poetry run python -m aiecs.scripts.aid.version_manager --bump patch
+# 1.1.0 -> 1.1.1
+```
+
+#### 次版本 (Minor)
+```bash
+poetry run python -m aiecs.scripts.aid.version_manager --bump minor
+# 1.1.0 -> 1.2.0
+```
+
+#### 主版本 (Major)
+```bash
+poetry run python -m aiecs.scripts.aid.version_manager --bump major
+# 1.1.0 -> 2.0.0
+```
+
+## 版本号格式
+
+版本号遵循 [语义化版本控制](https://semver.org/) 规范：
+
+- **主版本号 (Major)**: 不兼容的API修改
+- **次版本号 (Minor)**: 向下兼容的功能性新增
+- **补丁版本号 (Patch)**: 向下兼容的问题修正
+
+格式：`X.Y.Z` (例如：1.2.3)
+
+## 命令行选项
+
+- `--version, -v`: 设置特定版本号
+- `--bump, -b`: 自动递增版本 (major/minor/patch)
+- `--show, -s`: 显示当前版本
+- `--help, -h`: 显示帮助信息
+
+## 示例
+
+```bash
+# 查看当前版本
+poetry run python -m aiecs.scripts.aid.version_manager --show
+
+# 发布补丁版本
+poetry run python -m aiecs.scripts.aid.version_manager --bump patch
+
+# 发布新功能版本
+poetry run python -m aiecs.scripts.aid.version_manager --bump minor
+
+# 发布重大更新版本
+poetry run python -m aiecs.scripts.aid.version_manager --bump major
+
+# 手动设置版本
+poetry run python -m aiecs.scripts.aid.version_manager --version 2.1.0
+```
+
+## 注意事项
+
+1. 版本管理工具会自动验证版本号格式
+2. 所有相关文件会同时更新，确保版本号一致性
+3. 更新前建议先提交当前更改到版本控制系统
+4. 工具会显示详细的更新日志，确认所有文件都已正确更新
+
+## 故障排除
+
+如果遇到问题，请检查：
+
+1. 确保在项目根目录下运行命令
+2. 确保所有目标文件存在且可写
+3. 检查版本号格式是否正确 (X.Y.Z)
+4. 确保没有其他进程正在编辑这些文件

aiecs-1.1.1/aiecs/scripts/aid/__init__.py

@@ -0,0 +1,15 @@
+"""
+AIECS Development Tools (AID)
+
+This module contains development and maintenance tools for the AIECS project.
+"""
+
+# Lazy import to avoid circular import issues
+def get_version_manager_main():
+    """Get the version manager main function"""
+    from .version_manager import main
+    return main
+
+__all__ = [
+    'get_version_manager_main',
+]

aiecs-1.1.1/aiecs/scripts/aid/version_manager.py

@@ -0,0 +1,224 @@
+#!/usr/bin/env python3
+"""
+AIECS Version Manager
+
+A script to manage version numbers across multiple files in the AIECS project.
+Updates version numbers in:
+- aiecs/__init__.py (__version__)
+- aiecs/main.py (FastAPI app version and health check version)
+- pyproject.toml (project version)
+
+Usage:
+    aiecs-version --version 1.2.0
+    aiecs-version --bump patch
+    aiecs-version --bump minor
+    aiecs-version --bump major
+    aiecs-version --show
+"""
+
+import argparse
+import re
+import sys
+from pathlib import Path
+from typing import Optional, Tuple
+
+
+class VersionManager:
+    """Manages version numbers across AIECS project files"""
+    
+    def __init__(self, project_root: Optional[Path] = None):
+        """Initialize the version manager with project root path"""
+        if project_root is None:
+            # Find project root by looking for pyproject.toml
+            current = Path(__file__).parent
+            while current != current.parent:
+                if (current / "pyproject.toml").exists():
+                    project_root = current
+                    break
+                current = current.parent
+            
+            if project_root is None:
+                raise RuntimeError("Could not find project root (pyproject.toml)")
+        
+        self.project_root = project_root
+        self.files = {
+            'init': project_root / "aiecs" / "__init__.py",
+            'main': project_root / "aiecs" / "main.py", 
+            'pyproject': project_root / "pyproject.toml"
+        }
+    
+    def get_current_version(self) -> str:
+        """Get the current version from __init__.py"""
+        init_file = self.files['init']
+        if not init_file.exists():
+            raise FileNotFoundError(f"Could not find {init_file}")
+        
+        content = init_file.read_text(encoding='utf-8')
+        match = re.search(r'__version__\s*=\s*["\']([^"\']+)["\']', content)
+        if not match:
+            raise ValueError("Could not find __version__ in __init__.py")
+        
+        return match.group(1)
+    
+    def parse_version(self, version: str) -> Tuple[int, int, int]:
+        """Parse version string into major, minor, patch components"""
+        match = re.match(r'^(\d+)\.(\d+)\.(\d+)$', version)
+        if not match:
+            raise ValueError(f"Invalid version format: {version}. Expected format: X.Y.Z")
+        
+        return int(match.group(1)), int(match.group(2)), int(match.group(3))
+    
+    def bump_version(self, current_version: str, bump_type: str) -> str:
+        """Bump version based on type (major, minor, patch)"""
+        major, minor, patch = self.parse_version(current_version)
+        
+        if bump_type == 'major':
+            major += 1
+            minor = 0
+            patch = 0
+        elif bump_type == 'minor':
+            minor += 1
+            patch = 0
+        elif bump_type == 'patch':
+            patch += 1
+        else:
+            raise ValueError(f"Invalid bump type: {bump_type}. Use 'major', 'minor', or 'patch'")
+        
+        return f"{major}.{minor}.{patch}"
+    
+    def update_init_file(self, new_version: str) -> None:
+        """Update version in aiecs/__init__.py"""
+        init_file = self.files['init']
+        content = init_file.read_text(encoding='utf-8')
+        
+        # Update __version__ line
+        content = re.sub(
+            r'(__version__\s*=\s*["\'])([^"\']+)(["\'])',
+            rf'\g<1>{new_version}\g<3>',
+            content
+        )
+        
+        init_file.write_text(content, encoding='utf-8')
+        print(f"✓ Updated {init_file.relative_to(self.project_root)}: __version__ = \"{new_version}\"")
+    
+    def update_main_file(self, new_version: str) -> None:
+        """Update version in aiecs/main.py"""
+        main_file = self.files['main']
+        content = main_file.read_text(encoding='utf-8')
+        
+        # Update FastAPI app version
+        content = re.sub(
+            r'(version=")([^"]+)(")',
+            rf'\g<1>{new_version}\g<3>',
+            content
+        )
+        
+        # Update health check version
+        content = re.sub(
+            r'("version":\s*")([^"]+)(")',
+            rf'\g<1>{new_version}\g<3>',
+            content
+        )
+        
+        main_file.write_text(content, encoding='utf-8')
+        print(f"✓ Updated {main_file.relative_to(self.project_root)}: FastAPI version and health check version")
+    
+    def update_pyproject_file(self, new_version: str) -> None:
+        """Update version in pyproject.toml"""
+        pyproject_file = self.files['pyproject']
+        content = pyproject_file.read_text(encoding='utf-8')
+        
+        # Update project version (only in [project] section, not in [project.scripts])
+        # Use a more specific pattern to avoid updating script entry points
+        content = re.sub(
+            r'^(\s*version\s*=\s*")([^"]+)(")',
+            rf'\g<1>{new_version}\g<3>',
+            content,
+            flags=re.MULTILINE
+        )
+        
+        pyproject_file.write_text(content, encoding='utf-8')
+        print(f"✓ Updated {pyproject_file.relative_to(self.project_root)}: project version")
+    
+    def update_version(self, new_version: str) -> None:
+        """Update version in all files"""
+        # Validate version format
+        self.parse_version(new_version)
+        
+        print(f"Updating version to {new_version}...")
+        print()
+        
+        # Update all files
+        self.update_init_file(new_version)
+        self.update_main_file(new_version)
+        self.update_pyproject_file(new_version)
+        
+        print()
+        print(f"✓ Successfully updated version to {new_version} in all files!")
+    
+    def show_version(self) -> None:
+        """Show current version"""
+        try:
+            version = self.get_current_version()
+            print(f"Current version: {version}")
+        except Exception as e:
+            print(f"Error getting current version: {e}", file=sys.stderr)
+            sys.exit(1)
+
+
+def main():
+    """Main entry point for the version manager"""
+    parser = argparse.ArgumentParser(
+        description="AIECS Version Manager - Update version numbers across project files",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  aiecs-version --version 1.2.0          # Set specific version
+  aiecs-version --bump patch             # Bump patch version (1.1.0 -> 1.1.1)
+  aiecs-version --bump minor             # Bump minor version (1.1.0 -> 1.2.0)
+  aiecs-version --bump major             # Bump major version (1.1.0 -> 2.0.0)
+  aiecs-version --show                   # Show current version
+        """
+    )
+    
+    # Create mutually exclusive group for version options
+    version_group = parser.add_mutually_exclusive_group(required=True)
+    version_group.add_argument(
+        '--version', '-v',
+        type=str,
+        help='Set specific version (e.g., 1.2.0)'
+    )
+    version_group.add_argument(
+        '--bump', '-b',
+        choices=['major', 'minor', 'patch'],
+        help='Bump version: major (X.0.0), minor (X.Y.0), or patch (X.Y.Z)'
+    )
+    version_group.add_argument(
+        '--show', '-s',
+        action='store_true',
+        help='Show current version'
+    )
+    
+    args = parser.parse_args()
+    
+    try:
+        manager = VersionManager()
+        
+        if args.show:
+            manager.show_version()
+        elif args.version:
+            manager.update_version(args.version)
+        elif args.bump:
+            current_version = manager.get_current_version()
+            new_version = manager.bump_version(current_version, args.bump)
+            print(f"Bumping {args.bump} version: {current_version} -> {new_version}")
+            print()
+            manager.update_version(new_version)
+    
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == '__main__':
+    main()

aiecs-1.1.1/aiecs/scripts/dependance_check/__init__.py

@@ -0,0 +1,18 @@
+"""
+依赖检查和修复工具
+
+提供 AIECS 系统依赖的检查、修复和 NLP 数据下载功能。
+"""
+
+from .dependency_checker import main as dependency_checker_main
+from .dependency_fixer import main as dependency_fixer_main
+from .quick_dependency_check import main as quick_dependency_check_main
+from .download_nlp_data import main as download_nlp_data_main
+
+__all__ = [
+    'dependency_checker_main',
+    'dependency_fixer_main',
+    'quick_dependency_check_main',
+    'download_nlp_data_main',
+]
+