aiecs 1.5.1__py3-none-any.whl

aiecs/llm/utils/validate_config.py

@@ -0,0 +1,91 @@
+#!/usr/bin/env python3
+"""
+Validation script for LLM models configuration.
+
+This script validates the LLM models configuration file and prints
+information about configured providers and models.
+"""
+
+import sys
+import logging
+
+# Setup logging
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+)
+logger = logging.getLogger(__name__)
+
+
+def main():
+    """Main validation function"""
+    try:
+        from aiecs.llm.config import get_llm_config_loader, validate_llm_config
+
+        logger.info("=" * 70)
+        logger.info("LLM Models Configuration Validator")
+        logger.info("=" * 70)
+
+        # Load configuration
+        loader = get_llm_config_loader()
+        config = loader.get_config()
+
+        logger.info(f"\nConfiguration loaded from: {loader.get_config_path()}")
+
+        # Validate configuration
+        logger.info("\nValidating configuration...")
+        is_valid, warnings = validate_llm_config(config)
+
+        if is_valid:
+            logger.info("✓ Configuration is valid!")
+
+        # Print summary
+        logger.info("\n" + "=" * 70)
+        logger.info("Configuration Summary")
+        logger.info("=" * 70)
+
+        logger.info(f"\nTotal Providers: {len(config.providers)}")
+
+        for provider_name, provider_config in config.providers.items():
+            logger.info(f"\n{provider_name}:")
+            logger.info(f"  Default Model: {provider_config.default_model}")
+            logger.info(f"  Total Models: {len(provider_config.models)}")
+
+            if provider_config.model_mappings:
+                logger.info(f"  Model Aliases: {len(provider_config.model_mappings)}")
+
+            logger.info("  Available Models:")
+            for model in provider_config.models:
+                cost_str = (
+                    f"${model.costs.input:.6f} in / ${model.costs.output:.6f} out (per 1K tokens)"
+                )
+                logger.info(f"    - {model.name}: {cost_str}")
+                if model.capabilities.vision:
+                    logger.info("        Vision: Yes")
+                if model.capabilities.function_calling:
+                    logger.info("        Function Calling: Yes")
+
+        logger.info("\n" + "=" * 70)
+        logger.info("Validation Complete!")
+        logger.info("=" * 70)
+
+        if warnings:
+            logger.info(f"\nNote: {len(warnings)} warnings were generated during validation.")
+            logger.info("See logs above for details.")
+
+        return 0
+
+    except FileNotFoundError as e:
+        logger.error(f"\n✗ Configuration file not found: {e}")
+        logger.error("\nPlease ensure the LLM models configuration file exists at:")
+        logger.error("  - aiecs/config/llm_models.yaml")
+        logger.error("  - Or set LLM_MODELS_CONFIG environment variable")
+        return 1
+
+    except Exception as e:
+        logger.error(f"\n✗ Validation failed: {e}", exc_info=True)
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

aiecs/main.py

@@ -0,0 +1,363 @@
+"""
+AIECS - AI Execute Services
+A middleware service for AI-powered task execution and tool orchestration
+"""
+
+from fastapi import FastAPI, HTTPException, Request, status
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+from contextlib import asynccontextmanager
+import logging
+import os
+from typing import Optional
+import socketio
+
+# Import configuration
+from aiecs.config.config import get_settings
+
+# Import WebSocket server
+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,
+)
+from aiecs.infrastructure.monitoring import (
+    initialize_global_metrics,
+    close_global_metrics,
+)
+
+# Import LLM client factory
+from aiecs.llm.client_factory import LLMClientFactory
+
+# Import domain models
+from aiecs.domain.task.task_context import TaskContext
+
+# Import tool discovery
+from aiecs.tools import discover_tools
+
+# Setup logging
+logger = logging.getLogger(__name__)
+
+# Get settings
+settings = get_settings()
+
+# Global instances
+db_manager: Optional[DatabaseManager] = None
+task_manager: Optional[CeleryTaskManager] = None
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Application lifespan manager"""
+    global db_manager, task_manager
+
+    logger.info("Starting AIECS - AI Execute Services...")
+
+    # Setup structured logging
+    setup_structured_logging()
+
+    # Initialize global metrics (early in startup)
+    try:
+        await initialize_global_metrics()
+        logger.info("Global metrics initialized")
+    except Exception as e:
+        logger.warning(f"Global metrics initialization failed (continuing without it): {e}")
+
+    # Initialize database connection
+    try:
+        db_manager = DatabaseManager()
+        await db_manager.connect()
+        logger.info("Database connection established")
+    except Exception as e:
+        logger.error(f"Failed to connect to database: {e}")
+        raise
+
+    # Initialize task manager
+    try:
+        task_manager = CeleryTaskManager()
+        logger.info("Task manager initialized")
+    except Exception as e:
+        logger.error(f"Failed to initialize task manager: {e}")
+        raise
+
+    # Discover and register tools
+    try:
+        discover_tools("aiecs.tools")
+        logger.info("Tools discovered and registered")
+    except Exception as e:
+        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")
+
+    yield
+
+    # 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()
+        logger.info("Database connection closed")
+
+    # Close all LLM clients
+    await LLMClientFactory.close_all()
+    logger.info("LLM clients closed")
+
+    # Close global metrics
+    try:
+        await close_global_metrics()
+        logger.info("Global metrics closed")
+    except Exception as e:
+        logger.warning(f"Error closing global metrics: {e}")
+
+    logger.info("AIECS shutdown complete")
+
+
+# Create FastAPI app
+app = FastAPI(
+    title="AIECS - AI Execute Services",
+    description="Middleware service for AI-powered task execution and tool orchestration",
+    version="1.5.1",
+    lifespan=lifespan,
+)
+
+# Configure CORS
+allowed_origins = (
+    settings.cors_allowed_origins.split(",") if settings.cors_allowed_origins else ["*"]
+)
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=allowed_origins,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Mount Socket.IO app
+socket_app = socketio.ASGIApp(sio, other_asgi_app=app)
+
+
+# Health check endpoint
+@app.get("/health")
+async def health_check():
+    """Health check endpoint"""
+    return {"status": "healthy", "service": "aiecs", "version": "1.5.1"}
+
+
+# Metrics health check endpoint
+@app.get("/metrics/health")
+async def metrics_health():
+    """Check global metrics health"""
+    from aiecs.infrastructure.monitoring import (
+        is_metrics_initialized,
+        get_metrics_summary,
+    )
+
+    return {
+        "initialized": is_metrics_initialized(),
+        "summary": get_metrics_summary(),
+    }
+
+
+# Get available tools
+@app.get("/api/tools")
+async def get_available_tools():
+    """Get list of available tools"""
+    from aiecs.tools import list_tools
+
+    tools = list_tools()
+    return {"tools": tools, "count": len(tools)}
+
+
+# Execute task endpoint
+@app.post("/api/execute")
+async def execute_task(request: Request):
+    """Execute a task with given parameters"""
+    try:
+        data = await request.json()
+
+        # Extract required fields
+        task_type = data.get("type", "task")
+        mode = data.get("mode", "execute")
+        service = data.get("service", "default")
+        user_id = data.get("userId", "anonymous")
+        context_data = data.get("context", {})
+
+        # Build task context
+        task_context = TaskContext(
+            mode=mode,
+            service=service,
+            user_id=user_id,
+            metadata=context_data.get("metadata", {}),
+            data=context_data.get("data", {}),
+            tools=context_data.get("tools", []),
+        )
+
+        # Submit task to queue
+        if not task_manager:
+            raise HTTPException(
+                status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
+                detail="Task manager not initialized",
+            )
+
+        task_id = await task_manager.submit_task(context=task_context, task_type=task_type)
+
+        return {
+            "taskId": task_id,
+            "status": "queued",
+            "message": "Task submitted successfully",
+        }
+
+    except Exception as e:
+        logger.error(f"Error executing task: {e}")
+        raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=str(e))
+
+
+# Get task status
+@app.get("/api/task/{task_id}")
+async def get_task_status(task_id: str):
+    """Get status of a specific task"""
+    try:
+        if not task_manager:
+            raise HTTPException(
+                status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
+                detail="Task manager not initialized",
+            )
+
+        task_status = await task_manager.get_task_status(task_id)
+
+        if not task_status:
+            raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Task not found")
+
+        return task_status
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error getting task status: {e}")
+        raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=str(e))
+
+
+# Cancel task
+@app.delete("/api/task/{task_id}")
+async def cancel_task(task_id: str):
+    """Cancel a running task"""
+    try:
+        if not task_manager:
+            raise HTTPException(
+                status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
+                detail="Task manager not initialized",
+            )
+
+        success = await task_manager.cancel_task(task_id)
+
+        if not success:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail="Failed to cancel task",
+            )
+
+        return {
+            "taskId": task_id,
+            "status": "cancelled",
+            "message": "Task cancelled successfully",
+        }
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error cancelling task: {e}")
+        raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=str(e))
+
+
+# Get service info
+@app.get("/api/services")
+async def get_services():
+    """Get available AI services"""
+    from aiecs.config.registry import AI_SERVICE_REGISTRY
+
+    services = []
+    for (mode, service), cls in AI_SERVICE_REGISTRY.items():
+        services.append(
+            {
+                "mode": mode,
+                "service": service,
+                "class": cls.__name__,
+                "module": cls.__module__,
+            }
+        )
+
+    return {"services": services, "count": len(services)}
+
+
+# Get LLM providers
+@app.get("/api/providers")
+async def get_providers():
+    """Get available LLM providers"""
+    from aiecs.llm.client_factory import AIProvider
+
+    providers = [{"name": provider.value, "enabled": True} for provider in AIProvider]
+
+    return {"providers": providers, "count": len(providers)}
+
+
+# Exception handlers
+@app.exception_handler(HTTPException)
+async def http_exception_handler(request: Request, exc: HTTPException):
+    """Handle HTTP exceptions"""
+    return JSONResponse(
+        status_code=exc.status_code,
+        content={"error": exc.detail, "status": exc.status_code},
+    )
+
+
+@app.exception_handler(Exception)
+async def general_exception_handler(request: Request, exc: Exception):
+    """Handle general exceptions"""
+    logger.error(f"Unhandled exception: {exc}", exc_info=True)
+    return JSONResponse(
+        status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+        content={"error": "Internal server error", "status": 500},
+    )
+
+
+# Main entry point
+if __name__ == "__main__":
+    import uvicorn
+
+    # Get port from environment or use default
+    port = int(os.environ.get("PORT", 8000))
+
+    # Run the application with Socket.IO support
+    uvicorn.run(
+        socket_app,  # Use the combined Socket.IO + FastAPI app
+        host="0.0.0.0",
+        port=port,
+        log_level="info",
+        reload=bool(os.environ.get("RELOAD", False)),
+    )

aiecs/scripts/__init__.py

@@ -0,0 +1,3 @@
+"""
+Scripts for AIECS post-installation patches and utilities
+"""

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/scripts/aid/__init__.py

@@ -0,0 +1,19 @@
+"""
+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",
+]