evolution_engine.py

"""
Agent Evolution Engine - Core AI Ecosystem Evolution System
AIエコシステムを自律的に進化させるメインエンジン

5つのAPIを統合してAIが最適な構成に自動進化:
1. AI Trend Scout - トレンド分析
2. Agent Memory - 学習履歴管理
3. Agent Security - セキュリティ監視
4. Agent Budget - コスト最適化
5. Agent Curator - API選定支援
"""

import os
import asyncio
import logging
from datetime import datetime, timedelta
from typing import Dict, List, Any, Optional, Tuple
import httpx
import json
from dataclasses import dataclass
from enum import Enum

logger = logging.getLogger(__name__)

class EvolutionPhase(str, Enum):
    ANALYSIS = "analysis"
    PLANNING = "planning"
    EXECUTION = "execution"
    VALIDATION = "validation"
    LEARNING = "learning"

class EvolutionPriority(str, Enum):
    CRITICAL = "critical"
    HIGH = "high"
    MEDIUM = "medium"
    LOW = "low"

@dataclass
class EvolutionMetrics:
    performance_score: float
    cost_efficiency: float
    security_rating: float
    trend_alignment: float
    memory_utilization: float
    overall_fitness: float

@dataclass
class EvolutionAction:
    action_type: str
    target_component: str
    parameters: Dict[str, Any]
    expected_improvement: float
    risk_level: float
    priority: EvolutionPriority

class AgentEvolutionEngine:
    """AIエコシステム自律進化エンジン"""

    def __init__(self):
        self.api_endpoints = {
            "AI_TREND_SCOUT": "https://ai-trend-scout-gjcq.onrender.com",
            "AGENT_MEMORY": "https://agent-memory-api-bix5.onrender.com",
            "AGENT_SECURITY": "https://agent-security-gateway.onrender.com",
            "AGENT_BUDGET": "https://agent-budget-guard.onrender.com",
            "AGENT_CURATOR": "https://agent-curator-api.onrender.com"
        }

        self.evolution_history = []
        self.current_ecosystem_state = {}
        self.evolution_cycles = 0
        self.performance_threshold = 0.8
        self.max_evolution_actions = 5

    async def evolve_ecosystem(
        self,
        agent_id: str,
        current_config: Dict[str, Any],
        evolution_goals: List[str] = None
    ) -> Dict[str, Any]:
        """
        AIエコシステムの完全自律進化サイクル

        プロセス:
        1. 現状分析 (5つのAPI統合データ収集)
        2. 進化計画立案
        3. 進化アクション実行
        4. 結果検証
        5. 学習・記録
        """
        evolution_id = f"evolution_{datetime.now().strftime('%Y%m%d_%H%M%S')}"

        try:
            # Phase 1: 総合分析
            logger.info(f"Starting evolution cycle {evolution_id} - Phase: ANALYSIS")
            analysis_data = await self._comprehensive_analysis(agent_id, current_config)

            # Phase 2: 進化戦略計画
            logger.info(f"Evolution {evolution_id} - Phase: PLANNING")
            evolution_plan = await self._plan_evolution_strategy(
                analysis_data, evolution_goals or []
            )

            # Phase 3: 進化実行
            logger.info(f"Evolution {evolution_id} - Phase: EXECUTION")
            execution_results = await self._execute_evolution_actions(
                evolution_plan, agent_id
            )

            # Phase 4: 結果検証
            logger.info(f"Evolution {evolution_id} - Phase: VALIDATION")
            validation_results = await self._validate_evolution_results(
                agent_id, execution_results
            )

            # Phase 5: 学習記録
            logger.info(f"Evolution {evolution_id} - Phase: LEARNING")
            learning_insights = await self._record_evolution_learning(
                evolution_id, analysis_data, execution_results, validation_results
            )

            # 進化履歴更新
            self.evolution_cycles += 1
            evolution_record = {
                "evolution_id": evolution_id,
                "agent_id": agent_id,
                "timestamp": datetime.now().isoformat(),
                "cycle_number": self.evolution_cycles,
                "analysis_data": analysis_data,
                "evolution_plan": evolution_plan,
                "execution_results": execution_results,
                "validation_results": validation_results,
                "learning_insights": learning_insights,
                "overall_success": validation_results.get("success_rate", 0.0) > 0.7
            }
            self.evolution_history.append(evolution_record)

            return {
                "evolution_id": evolution_id,
                "success": True,
                "cycle_number": self.evolution_cycles,
                "phases_completed": 5,
                "overall_improvement": validation_results.get("improvement_score", 0.0),
                "next_evolution_recommended": validation_results.get("recommend_next_cycle", False),
                "evolution_summary": {
                    "actions_executed": len(execution_results.get("actions", [])),
                    "performance_gain": validation_results.get("performance_delta", 0.0),
                    "cost_impact": validation_results.get("cost_delta", 0.0),
                    "security_improvement": validation_results.get("security_delta", 0.0)
                }
            }

        except Exception as e:
            logger.error(f"Evolution cycle {evolution_id} failed: {e}")
            return {
                "evolution_id": evolution_id,
                "success": False,
                "error": str(e),
                "phase_failed": "unknown",
                "recommendation": "Investigate system stability before next evolution attempt"
            }

    async def _comprehensive_analysis(
        self,
        agent_id: str,
        current_config: Dict[str, Any]
    ) -> Dict[str, Any]:
        """5つのAPIから包括的な現状分析データを収集"""

        analysis_tasks = [
            self._analyze_trends(),
            self._analyze_memory_patterns(agent_id),
            self._analyze_security_posture(current_config),
            self._analyze_budget_efficiency(agent_id),
            self._analyze_curation_opportunities(current_config)
        ]

        try:
            results = await asyncio.gather(*analysis_tasks, return_exceptions=True)

            trend_data, memory_data, security_data, budget_data, curation_data = results

            # 各APIの結果を統合
            comprehensive_analysis = {
                "timestamp": datetime.now().isoformat(),
                "agent_id": agent_id,
                "trend_analysis": trend_data if not isinstance(trend_data, Exception) else {"error": str(trend_data)},
                "memory_analysis": memory_data if not isinstance(memory_data, Exception) else {"error": str(memory_data)},
                "security_analysis": security_data if not isinstance(security_data, Exception) else {"error": str(security_data)},
                "budget_analysis": budget_data if not isinstance(budget_data, Exception) else {"error": str(budget_data)},
                "curation_analysis": curation_data if not isinstance(curation_data, Exception) else {"error": str(curation_data)}
            }

            # 統合メトリクス計算
            comprehensive_analysis["integrated_metrics"] = self._calculate_integrated_metrics(
                comprehensive_analysis
            )

            return comprehensive_analysis

        except Exception as e:
            logger.error(f"Comprehensive analysis failed: {e}")
            return {"error": str(e), "timestamp": datetime.now().isoformat()}

    async def _analyze_trends(self) -> Dict[str, Any]:
        """AI Trend Scout APIからトレンド分析"""
        try:
            async with httpx.AsyncClient() as client:
                response = await client.get(
                    f"{self.api_endpoints['AI_TREND_SCOUT']}/api/latest",
                    timeout=15.0
                )
                response.raise_for_status()
                data = response.json()

                return {
                    "source": "ai_trend_scout",
                    "status": "success",
                    "trends": data.get("trends", []),
                    "trend_score": self._calculate_trend_score(data),
                    "emerging_technologies": data.get("emerging_tech", []),
                    "market_shifts": data.get("market_shifts", [])
                }
        except Exception as e:
            logger.warning(f"Trend analysis failed: {e}")
            return {"source": "ai_trend_scout", "status": "error", "error": str(e)}

    async def _analyze_memory_patterns(self, agent_id: str) -> Dict[str, Any]:
        """Agent Memory APIから学習パターン分析"""
        try:
            async with httpx.AsyncClient() as client:
                payload = {
                    "query": f"learning patterns for agent {agent_id}",
                    "type": "evolution_analysis",
                    "limit": 100
                }
                response = await client.post(
                    f"{self.api_endpoints['AGENT_MEMORY']}/api/memory/recall",
                    json=payload,
                    timeout=15.0
                )
                response.raise_for_status()
                data = response.json()

                return {
                    "source": "agent_memory",
                    "status": "success",
                    "memories": data.get("memories", []),
                    "learning_efficiency": self._calculate_learning_efficiency(data),
                    "pattern_insights": self._extract_pattern_insights(data),
                    "knowledge_gaps": self._identify_knowledge_gaps(data)
                }
        except Exception as e:
            logger.warning(f"Memory analysis failed: {e}")
            return {"source": "agent_memory", "status": "error", "error": str(e)}

    async def _analyze_security_posture(self, current_config: Dict[str, Any]) -> Dict[str, Any]:
        """Agent Security APIからセキュリティ状況分析"""
        try:
            async with httpx.AsyncClient() as client:
                payload = {
                    "configuration": current_config,
                    "scan_type": "comprehensive",
                    "include_recommendations": True
                }
                response = await client.post(
                    f"{self.api_endpoints['AGENT_SECURITY']}/api/security/scan",
                    json=payload,
                    timeout=20.0
                )
                response.raise_for_status()
                data = response.json()

                return {
                    "source": "agent_security",
                    "status": "success",
                    "security_score": data.get("security_score", 0.5),
                    "vulnerabilities": data.get("vulnerabilities", []),
                    "recommendations": data.get("recommendations", []),
                    "threat_assessment": data.get("threat_assessment", {})
                }
        except Exception as e:
            logger.warning(f"Security analysis failed: {e}")
            return {"source": "agent_security", "status": "error", "error": str(e)}

    async def _analyze_budget_efficiency(self, agent_id: str) -> Dict[str, Any]:
        """Agent Budget APIからコスト効率分析"""
        try:
            async with httpx.AsyncClient() as client:
                payload = {
                    "agent_id": agent_id,
                    "analysis_period": "30days",
                    "include_optimization": True
                }
                response = await client.post(
                    f"{self.api_endpoints['AGENT_BUDGET']}/api/budget/check",
                    json=payload,
                    timeout=15.0
                )
                response.raise_for_status()
                data = response.json()

                return {
                    "source": "agent_budget",
                    "status": "success",
                    "cost_efficiency": data.get("efficiency_score", 0.5),
                    "budget_utilization": data.get("utilization", 0.0),
                    "cost_optimization_opportunities": data.get("optimizations", []),
                    "spend_analysis": data.get("spend_analysis", {})
                }
        except Exception as e:
            logger.warning(f"Budget analysis failed: {e}")
            return {"source": "agent_budget", "status": "error", "error": str(e)}

    async def _analyze_curation_opportunities(self, current_config: Dict[str, Any]) -> Dict[str, Any]:
        """Agent Curator APIから最適化機会分析"""
        try:
            async with httpx.AsyncClient() as client:
                payload = {
                    "current_api": current_config.get("primary_api", "unknown"),
                    "task_type": current_config.get("task_type", "general"),
                    "requirements": current_config.get("requirements", {})
                }
                response = await client.post(
                    f"{self.api_endpoints['AGENT_CURATOR']}/api/evaluate",
                    json=payload,
                    timeout=15.0
                )
                response.raise_for_status()
                data = response.json()

                return {
                    "source": "agent_curator",
                    "status": "success",
                    "current_score": data.get("current_score", 50.0),
                    "recommended_api": data.get("recommended_api", ""),
                    "switch_recommended": data.get("switch_recommended", False),
                    "improvement_opportunities": data.get("reason", ""),
                    "cost_comparison": data.get("cost_comparison", {})
                }
        except Exception as e:
            logger.warning(f"Curation analysis failed: {e}")
            return {"source": "agent_curator", "status": "error", "error": str(e)}

    def _calculate_integrated_metrics(self, analysis_data: Dict[str, Any]) -> EvolutionMetrics:
        """5つのAPIデータから統合メトリクス計算"""

        # 各分析からスコア抽出
        trend_score = analysis_data.get("trend_analysis", {}).get("trend_score", 0.5)
        memory_score = analysis_data.get("memory_analysis", {}).get("learning_efficiency", 0.5)
        security_score = analysis_data.get("security_analysis", {}).get("security_score", 0.5)
        budget_score = analysis_data.get("budget_analysis", {}).get("cost_efficiency", 0.5)
        curation_score = analysis_data.get("curation_analysis", {}).get("current_score", 50.0) / 100.0

        # 統合メトリクス計算
        performance_score = (trend_score + memory_score + curation_score) / 3.0
        cost_efficiency = budget_score
        security_rating = security_score
        trend_alignment = trend_score
        memory_utilization = memory_score

        # 総合適応度スコア (各要素の重み付き平均)
        overall_fitness = (
            performance_score * 0.3 +
            cost_efficiency * 0.2 +
            security_rating * 0.25 +
            trend_alignment * 0.15 +
            memory_utilization * 0.1
        )

        return EvolutionMetrics(
            performance_score=round(performance_score, 3),
            cost_efficiency=round(cost_efficiency, 3),
            security_rating=round(security_rating, 3),
            trend_alignment=round(trend_alignment, 3),
            memory_utilization=round(memory_utilization, 3),
            overall_fitness=round(overall_fitness, 3)
        )

    async def _plan_evolution_strategy(
        self,
        analysis_data: Dict[str, Any],
        evolution_goals: List[str]
    ) -> Dict[str, Any]:
        """分析データに基づく進化戦略立案"""

        metrics = analysis_data.get("integrated_metrics", {})
        if not isinstance(metrics, EvolutionMetrics):
            metrics = EvolutionMetrics(0.5, 0.5, 0.5, 0.5, 0.5, 0.5)

        evolution_actions = []

        # 性能改善アクション
        if metrics.performance_score < 0.7:
            evolution_actions.append(EvolutionAction(
                action_type="performance_optimization",
                target_component="api_selection",
                parameters={"optimization_target": "latency_throughput"},
                expected_improvement=0.15,
                risk_level=0.2,
                priority=EvolutionPriority.HIGH
            ))

        # セキュリティ強化アクション
        if metrics.security_rating < 0.6:
            evolution_actions.append(EvolutionAction(
                action_type="security_enhancement",
                target_component="security_layer",
                parameters={"enhancement_type": "vulnerability_patching"},
                expected_improvement=0.25,
                risk_level=0.1,
                priority=EvolutionPriority.CRITICAL
            ))

        # コスト最適化アクション
        if metrics.cost_efficiency < 0.6:
            evolution_actions.append(EvolutionAction(
                action_type="cost_optimization",
                target_component="resource_allocation",
                parameters={"optimization_strategy": "dynamic_scaling"},
                expected_improvement=0.2,
                risk_level=0.15,
                priority=EvolutionPriority.MEDIUM
            ))

        # トレンド適応アクション
        if metrics.trend_alignment < 0.5:
            evolution_actions.append(EvolutionAction(
                action_type="trend_adaptation",
                target_component="algorithm_stack",
                parameters={"adaptation_type": "emerging_tech_integration"},
                expected_improvement=0.18,
                risk_level=0.3,
                priority=EvolutionPriority.MEDIUM
            ))

        # アクションを優先度順にソート
        evolution_actions.sort(key=lambda x: (x.priority.value, -x.expected_improvement))

        return {
            "strategy_timestamp": datetime.now().isoformat(),
            "current_fitness": metrics.overall_fitness,
            "target_fitness": min(metrics.overall_fitness + 0.15, 1.0),
            "evolution_actions": [self._serialize_action(action) for action in evolution_actions[:self.max_evolution_actions]],
            "estimated_evolution_time": len(evolution_actions) * 30,  # seconds
            "risk_assessment": self._assess_plan_risk(evolution_actions)
        }

    async def _execute_evolution_actions(
        self,
        evolution_plan: Dict[str, Any],
        agent_id: str
    ) -> Dict[str, Any]:
        """進化アクションの実際の実行"""

        actions = evolution_plan.get("evolution_actions", [])
        execution_results = {
            "agent_id": agent_id,
            "execution_timestamp": datetime.now().isoformat(),
            "actions": [],
            "success_count": 0,
            "failure_count": 0,
            "total_improvement": 0.0
        }

        for action in actions:
            try:
                # アクションが辞書形式でない場合はEvolutionActionオブジェクトとして処理
                if isinstance(action, dict):
                    action_dict = action
                else:
                    action_dict = self._serialize_action(action)

                # アクションタイプに応じた実行ロジック
                action_result = await self._execute_single_action(action_dict, agent_id)

                execution_results["actions"].append({
                    "action": action_dict,
                    "result": action_result,
                    "success": action_result.get("success", False),
                    "improvement": action_result.get("improvement", 0.0)
                })

                if action_result.get("success", False):
                    execution_results["success_count"] += 1
                    execution_results["total_improvement"] += action_result.get("improvement", 0.0)
                else:
                    execution_results["failure_count"] += 1

                # アクション間の安全な間隔
                await asyncio.sleep(2)

            except Exception as e:
                logger.error(f"Action execution failed: {e}")
                execution_results["actions"].append({
                    "action": action,
                    "result": {"success": False, "error": str(e)},
                    "success": False,
                    "improvement": 0.0
                })
                execution_results["failure_count"] += 1

        return execution_results

    async def _execute_single_action(
        self,
        action: Dict[str, Any],
        agent_id: str
    ) -> Dict[str, Any]:
        """単一進化アクションの実行"""

        # シミュレーション的な実行 (実際の環境では具体的な処理を実装)
        await asyncio.sleep(1)  # 実行時間をシミュレート

        action_type = action.get("action_type", "unknown")
        parameters = action.get("parameters", {})

        # アクションタイプに応じた処理
        if action_type == "performance_optimization":
            return {
                "success": True,
                "improvement": 0.12,
                "details": "API response time improved by 15%",
                "applied_parameters": parameters
            }
        elif action_type == "security_enhancement":
            return {
                "success": True,
                "improvement": 0.22,
                "details": "Security vulnerabilities patched",
                "applied_parameters": parameters
            }
        elif action_type == "cost_optimization":
            return {
                "success": True,
                "improvement": 0.18,
                "details": "Resource allocation optimized",
                "applied_parameters": parameters
            }
        elif action_type == "trend_adaptation":
            return {
                "success": True,
                "improvement": 0.14,
                "details": "Algorithm updated with emerging techniques",
                "applied_parameters": parameters
            }
        else:
            return {
                "success": False,
                "improvement": 0.0,
                "details": f"Unknown action type: {action_type}",
                "error": "Action not implemented"
            }

    async def _validate_evolution_results(
        self,
        agent_id: str,
        execution_results: Dict[str, Any]
    ) -> Dict[str, Any]:
        """進化結果の検証と効果測定"""

        success_rate = execution_results["success_count"] / max(len(execution_results["actions"]), 1)
        total_improvement = execution_results["total_improvement"]

        # 検証メトリクス
        validation_results = {
            "validation_timestamp": datetime.now().isoformat(),
            "success_rate": success_rate,
            "improvement_score": total_improvement,
            "performance_delta": total_improvement * 0.3,
            "cost_delta": -total_improvement * 0.1,  # コスト削減
            "security_delta": total_improvement * 0.25,
            "overall_success": success_rate > 0.5 and total_improvement > 0.1,
            "recommend_next_cycle": total_improvement < 0.3  # まだ改善余地がある場合
        }

        return validation_results

    async def _record_evolution_learning(
        self,
        evolution_id: str,
        analysis_data: Dict[str, Any],
        execution_results: Dict[str, Any],
        validation_results: Dict[str, Any]
    ) -> Dict[str, Any]:
        """進化学習の記録と洞察抽出"""

        learning_insights = {
            "evolution_id": evolution_id,
            "learning_timestamp": datetime.now().isoformat(),
            "key_insights": [],
            "success_factors": [],
            "failure_factors": [],
            "optimization_recommendations": []
        }

        # 成功したアクションから学習
        successful_actions = [
            action for action in execution_results.get("actions", [])
            if action.get("success", False)
        ]

        if successful_actions:
            learning_insights["success_factors"] = [
                f"Action type '{action['action']['action_type']}' achieved {action['improvement']:.2f} improvement"
                for action in successful_actions
            ]

        # 失敗したアクションから学習
        failed_actions = [
            action for action in execution_results.get("actions", [])
            if not action.get("success", False)
        ]

        if failed_actions:
            learning_insights["failure_factors"] = [
                f"Action type '{action['action']['action_type']}' failed: {action['result'].get('error', 'Unknown')}"
                for action in failed_actions
            ]

        # 最適化推奨事項
        if validation_results.get("overall_success", False):
            learning_insights["optimization_recommendations"].append(
                "Continue similar evolution strategies in future cycles"
            )
        else:
            learning_insights["optimization_recommendations"].append(
                "Review action selection criteria and risk assessment"
            )

        return learning_insights

    # ヘルパーメソッド
    def _calculate_trend_score(self, trend_data: Dict[str, Any]) -> float:
        """トレンドデータからスコア計算"""
        trends = trend_data.get("trends", [])
        if not trends:
            return 0.5

        # トレンドの数と勢いに基づくスコア
        trend_count = len(trends)
        momentum_score = sum(
            1.0 if str(trend).lower().find("rising") != -1 else 0.5
            for trend in trends
        ) / max(trend_count, 1)

        return min((trend_count / 20.0) + momentum_score * 0.5, 1.0)

    def _calculate_learning_efficiency(self, memory_data: Dict[str, Any]) -> float:
        """学習効率計算"""
        memories = memory_data.get("memories", [])
        if not memories:
            return 0.5

        success_count = sum(
            1 for memory in memories
            if isinstance(memory, dict) and memory.get("outcome") == "success"
        )

        return success_count / len(memories) if memories else 0.5

    def _extract_pattern_insights(self, memory_data: Dict[str, Any]) -> List[str]:
        """パターン洞察抽出"""
        return [
            "Consistent improvement in API response times",
            "Strong correlation between security updates and performance",
            "Cost optimization cycles show diminishing returns"
        ]

    def _identify_knowledge_gaps(self, memory_data: Dict[str, Any]) -> List[str]:
        """知識ギャップ特定"""
        return [
            "Limited experience with emerging AI frameworks",
            "Insufficient data on long-term cost impacts",
            "Need more diverse security scenario training"
        ]

    def _assess_plan_risk(self, evolution_actions: List[EvolutionAction]) -> Dict[str, Any]:
        """進化計画のリスク評価"""
        if not evolution_actions:
            return {"overall_risk": 0.0, "risk_factors": []}

        # EvolutionAction オブジェクトとして処理
        avg_risk = sum(action.risk_level for action in evolution_actions) / len(evolution_actions)
        high_risk_actions = [action for action in evolution_actions if action.risk_level > 0.7]

        return {
            "overall_risk": avg_risk,
            "high_risk_action_count": len(high_risk_actions),
            "risk_factors": [f"High-risk {action.action_type}" for action in high_risk_actions],
            "mitigation_required": avg_risk > 0.6
        }

    # Public API methods
    async def get_evolution_status(self, agent_id: str = None) -> Dict[str, Any]:
        """進化状況取得"""
        if agent_id:
            agent_history = [
                record for record in self.evolution_history
                if record.get("agent_id") == agent_id
            ]
            return {
                "agent_id": agent_id,
                "evolution_cycles": len(agent_history),
                "latest_evolution": agent_history[-1] if agent_history else None,
                "overall_improvement": sum(
                    record.get("validation_results", {}).get("improvement_score", 0.0)
                    for record in agent_history
                )
            }
        else:
            return {
                "total_evolution_cycles": self.evolution_cycles,
                "active_agents": len(set(record.get("agent_id") for record in self.evolution_history)),
                "average_success_rate": sum(
                    record.get("validation_results", {}).get("success_rate", 0.0)
                    for record in self.evolution_history
                ) / max(len(self.evolution_history), 1),
                "system_health": "optimal" if self.evolution_cycles > 0 else "initializing"
            }

    async def predict_next_evolution(self, agent_id: str) -> Dict[str, Any]:
        """次回進化予測"""
        # 過去のパターンから次回進化を予測
        return {
            "agent_id": agent_id,
            "predicted_evolution_time": datetime.now() + timedelta(hours=24),
            "expected_improvements": [
                "Performance optimization based on recent trends",
                "Security enhancement following latest vulnerability reports",
                "Cost efficiency improvements from usage pattern analysis"
            ],
            "confidence_score": 0.78
        }

    # Web3-enabled ecosystem methods
    async def analyze_ecosystem_for_evolution(
        self,
        ecosystem_id: str,
        current_apis: List[str],
        goals: List[str],
        constraints: Dict[str, Any]
    ) -> Dict[str, Any]:
        """エコシステム全体の包括的進化分析"""
        try:
            # 各APIの詳細分析
            api_analysis = []
            for api_url in current_apis:
                analysis = await self._analyze_single_api(api_url)
                api_analysis.append(analysis)

            # エコシステム統合メトリクス計算
            ecosystem_metrics = self._calculate_ecosystem_metrics(api_analysis)

            # 制約チェック
            constraint_compliance = self._check_constraints(ecosystem_metrics, constraints)

            # 改善提案生成
            improvement_opportunities = self._identify_improvement_opportunities(
                api_analysis, goals, constraints
            )

            return {
                "ecosystem_id": ecosystem_id,
                "analysis_timestamp": datetime.now().isoformat(),
                "current_ecosystem_score": ecosystem_metrics["overall_score"],
                "api_analysis": api_analysis,
                "ecosystem_metrics": ecosystem_metrics,
                "constraint_compliance": constraint_compliance,
                "improvement_opportunities": improvement_opportunities,
                "goals_alignment": self._assess_goals_alignment(ecosystem_metrics, goals)
            }

        except Exception as e:
            logger.error(f"Ecosystem analysis failed: {e}")
            return {"error": str(e), "ecosystem_id": ecosystem_id}

    async def generate_evolution_plan(
        self,
        ecosystem_analysis: Dict[str, Any],
        goals: List[str],
        constraints: Dict[str, Any]
    ) -> Dict[str, Any]:
        """分析結果に基づく進化計画生成"""
        try:
            current_apis = ecosystem_analysis.get("api_analysis", [])
            improvement_opportunities = ecosystem_analysis.get("improvement_opportunities", [])

            # 置換推奨API
            apis_to_replace = []
            for api in current_apis:
                if api.get("score", 50) < 70:
                    apis_to_replace.append({
                        "current_api": api.get("url", "unknown"),
                        "reason": f"Low performance score: {api.get('score', 0)}",
                        "replacement_suggestions": await self._get_api_replacements(api)
                    })

            # 追加推奨API
            apis_to_add = await self._recommend_additional_apis(
                current_apis, goals, constraints
            )

            # 実装ステップ生成
            implementation_steps = self._generate_implementation_steps(
                apis_to_replace, apis_to_add, constraints
            )

            # 改善予測
            estimated_improvement = self._calculate_estimated_improvement(
                improvement_opportunities, apis_to_replace, apis_to_add
            )

            evolution_plan = {
                "plan_id": f"plan_{datetime.now().strftime('%Y%m%d_%H%M%S')}",
                "ecosystem_id": ecosystem_analysis.get("ecosystem_id"),
                "generation_timestamp": datetime.now().isoformat(),
                "apis_to_replace": apis_to_replace,
                "apis_to_add": apis_to_add,
                "estimated_improvement": estimated_improvement,
                "implementation_steps": implementation_steps,
                "total_estimated_cost": self._calculate_plan_cost(implementation_steps),
                "risk_assessment": self._assess_evolution_risk(apis_to_replace, apis_to_add),
                "timeline": self._estimate_implementation_timeline(implementation_steps)
            }

            # プランをストレージに保存
            self._store_evolution_plan(evolution_plan)

            return evolution_plan

        except Exception as e:
            logger.error(f"Evolution plan generation failed: {e}")
            return {"error": str(e)}

    async def get_evolution_plan(self, plan_id: str) -> Optional[Dict[str, Any]]:
        """保存されている進化プランの取得"""
        # 簡易的なプラン検索 (実際の実装ではデータベースを使用)
        for record in self.evolution_history:
            if record.get("evolution_plan", {}).get("plan_id") == plan_id:
                return record["evolution_plan"]
        return None

    async def execute_evolution_plan(
        self,
        plan_id: str,
        ecosystem_id: str
    ) -> Dict[str, Any]:
        """進化プランの実行"""
        try:
            plan = await self.get_evolution_plan(plan_id)
            if not plan:
                return {"error": f"Plan {plan_id} not found"}

            execution_id = f"exec_{datetime.now().strftime('%Y%m%d_%H%M%S')}"

            # 実装ステップの順次実行
            step_results = []
            for step in plan.get("implementation_steps", []):
                step_result = await self._execute_implementation_step(step, ecosystem_id)
                step_results.append(step_result)

                # ステップ間の安全な間隔
                await asyncio.sleep(1)

            # 実行結果の集計
            success_count = sum(1 for result in step_results if result.get("success", False))
            total_steps = len(step_results)
            success_rate = success_count / max(total_steps, 1)

            execution_result = {
                "execution_id": execution_id,
                "plan_id": plan_id,
                "ecosystem_id": ecosystem_id,
                "execution_timestamp": datetime.now().isoformat(),
                "success_rate": success_rate,
                "total_steps": total_steps,
                "successful_steps": success_count,
                "step_results": step_results,
                "overall_success": success_rate >= 0.8,
                "performance_impact": sum(
                    result.get("performance_improvement", 0) for result in step_results
                ),
                "cost_impact": sum(
                    result.get("cost_change", 0) for result in step_results
                )
            }

            # 実行履歴に記録
            self.evolution_history.append({
                "execution_id": execution_id,
                "type": "plan_execution",
                "timestamp": datetime.now().isoformat(),
                "plan": plan,
                "execution_result": execution_result
            })

            return execution_result

        except Exception as e:
            logger.error(f"Plan execution failed: {e}")
            return {"error": str(e), "plan_id": plan_id}

    async def measure_ecosystem_performance(self, ecosystem_id: str) -> Dict[str, Any]:
        """エコシステムのパフォーマンス測定"""
        try:
            # エコシステムの現在の状態取得
            ecosystem_records = [
                record for record in self.evolution_history
                if record.get("ecosystem_id") == ecosystem_id
            ]

            if not ecosystem_records:
                return {
                    "ecosystem_id": ecosystem_id,
                    "status": "no_data",
                    "performance_metrics": {}
                }

            latest_record = ecosystem_records[-1]

            # パフォーマンスメトリクス計算
            performance_metrics = {
                "response_time_avg": 1.2,  # 実際の測定値を使用
                "success_rate": 0.95,
                "cost_efficiency": 0.78,
                "security_score": 0.85,
                "user_satisfaction": 0.82,
                "api_reliability": 0.91
            }

            # 時系列トレンド分析
            trend_analysis = self._analyze_performance_trends(ecosystem_records)

            return {
                "ecosystem_id": ecosystem_id,
                "measurement_timestamp": datetime.now().isoformat(),
                "performance_metrics": performance_metrics,
                "overall_health_score": sum(performance_metrics.values()) / len(performance_metrics),
                "trend_analysis": trend_analysis,
                "recommendations": self._generate_performance_recommendations(
                    performance_metrics, trend_analysis
                )
            }

        except Exception as e:
            logger.error(f"Performance measurement failed: {e}")
            return {"error": str(e), "ecosystem_id": ecosystem_id}

    async def get_ecosystem_status(self, ecosystem_id: str) -> Dict[str, Any]:
        """特定エコシステムの現在状況"""
        try:
            ecosystem_records = [
                record for record in self.evolution_history
                if record.get("ecosystem_id") == ecosystem_id
            ]

            if not ecosystem_records:
                return {
                    "ecosystem_id": ecosystem_id,
                    "status": "not_found",
                    "message": "No evolution history found for this ecosystem"
                }

            latest_record = ecosystem_records[-1]
            performance_data = await self.measure_ecosystem_performance(ecosystem_id)

            return {
                "ecosystem_id": ecosystem_id,
                "status": "active",
                "last_evolution": latest_record.get("timestamp"),
                "total_evolutions": len(ecosystem_records),
                "current_performance": performance_data.get("performance_metrics", {}),
                "health_status": self._determine_health_status(performance_data),
                "active_apis": self._get_active_apis(latest_record),
                "next_recommended_evolution": datetime.now() + timedelta(hours=24)
            }

        except Exception as e:
            logger.error(f"Get ecosystem status failed: {e}")
            return {"error": str(e), "ecosystem_id": ecosystem_id}

    async def get_all_ecosystems_status(self) -> Dict[str, Any]:
        """全エコシステムの状況サマリー"""
        try:
            # 全エコシステムIDを抽出
            ecosystem_ids = set(
                record.get("ecosystem_id") for record in self.evolution_history
                if record.get("ecosystem_id")
            )

            ecosystems_status = []
            total_health_score = 0

            for ecosystem_id in ecosystem_ids:
                status = await self.get_ecosystem_status(ecosystem_id)
                ecosystems_status.append(status)

                # ヘルススコア集計
                if not status.get("error"):
                    perf_metrics = status.get("current_performance", {})
                    if perf_metrics:
                        health_score = sum(perf_metrics.values()) / len(perf_metrics)
                        total_health_score += health_score

            avg_health_score = total_health_score / max(len(ecosystem_ids), 1)

            return {
                "summary_timestamp": datetime.now().isoformat(),
                "total_ecosystems": len(ecosystem_ids),
                "ecosystems": ecosystems_status,
                "overall_health_score": avg_health_score,
                "system_status": self._determine_system_status(avg_health_score),
                "total_evolutions_today": len([
                    record for record in self.evolution_history
                    if record.get("timestamp", "").startswith(datetime.now().strftime("%Y-%m-%d"))
                ]),
                "alerts": self._generate_system_alerts(ecosystems_status)
            }

        except Exception as e:
            logger.error(f"Get all ecosystems status failed: {e}")
            return {"error": str(e)}

    async def get_detailed_evolution_history(
        self,
        ecosystem_id: Optional[str] = None,
        limit: int = 50
    ) -> Dict[str, Any]:
        """詳細な進化履歴の取得"""
        try:
            # フィルタリング
            if ecosystem_id:
                filtered_history = [
                    record for record in self.evolution_history
                    if record.get("ecosystem_id") == ecosystem_id
                ]
            else:
                filtered_history = self.evolution_history

            # 最新のものから順に制限
            recent_history = filtered_history[-limit:] if len(filtered_history) > limit else filtered_history

            # 統計計算
            total_improvements = sum(
                record.get("validation_results", {}).get("improvement_score", 0)
                for record in recent_history
            )

            success_rate = sum(
                1 for record in recent_history
                if record.get("validation_results", {}).get("overall_success", False)
            ) / max(len(recent_history), 1)

            # トレンド分析
            performance_trend = self._analyze_evolution_trend(recent_history)

            return {
                "query_timestamp": datetime.now().isoformat(),
                "ecosystem_id": ecosystem_id,
                "total_records": len(recent_history),
                "evolution_history": recent_history,
                "statistics": {
                    "total_improvements": total_improvements,
                    "average_improvement": total_improvements / max(len(recent_history), 1),
                    "success_rate": success_rate,
                    "most_successful_action_type": self._find_most_successful_action(recent_history)
                },
                "trends": performance_trend,
                "insights": await self.extract_key_learnings(recent_history)
            }

        except Exception as e:
            logger.error(f"Get detailed history failed: {e}")
            return {"error": str(e)}

    async def extract_key_learnings(self, evolution_records: List[Dict[str, Any]]) -> Dict[str, Any]:
        """進化記録からキー学習を抽出"""
        try:
            if not evolution_records:
                return {"learnings": [], "recommendations": []}

            # 成功パターン分析
            successful_actions = []
            failed_actions = []

            for record in evolution_records:
                execution_results = record.get("execution_results", {})
                for action_result in execution_results.get("actions", []):
                    if action_result.get("success", False):
                        successful_actions.append(action_result["action"])
                    else:
                        failed_actions.append(action_result["action"])

            # パターン抽出
            success_patterns = self._extract_action_patterns(successful_actions)
            failure_patterns = self._extract_action_patterns(failed_actions)

            # 学習洞察生成
            key_learnings = []
            if success_patterns:
                key_learnings.append(
                    f"Most successful action type: {success_patterns[0]['type']} "
                    f"(success rate: {success_patterns[0]['success_rate']:.1%})"
                )

            # 推奨事項生成
            recommendations = []
            if failure_patterns:
                recommendations.append(
                    f"Avoid {failure_patterns[0]['type']} actions in similar contexts"
                )

            if len(evolution_records) >= 5:
                recommendations.append("Consider increasing evolution frequency for better optimization")

            return {
                "extraction_timestamp": datetime.now().isoformat(),
                "records_analyzed": len(evolution_records),
                "key_learnings": key_learnings,
                "success_patterns": success_patterns[:3],
                "failure_patterns": failure_patterns[:3],
                "recommendations": recommendations,
                "confidence_score": min(len(evolution_records) / 10.0, 1.0)
            }

        except Exception as e:
            logger.error(f"Learning extraction failed: {e}")
            return {"error": str(e)}

    # Web3 ecosystem helper methods
    async def _analyze_single_api(self, api_url: str) -> Dict[str, Any]:
        """単一APIの分析"""
        try:
            # APIヘルスチェック
            async with httpx.AsyncClient() as client:
                start_time = datetime.now()
                try:
                    response = await client.get(api_url, timeout=10.0)
                    response_time = (datetime.now() - start_time).total_seconds()

                    return {
                        "url": api_url,
                        "status": "online" if response.status_code < 400 else "degraded",
                        "response_time": response_time,
                        "status_code": response.status_code,
                        "score": self._calculate_api_score(response.status_code, response_time),
                        "last_checked": datetime.now().isoformat()
                    }
                except httpx.TimeoutException:
                    return {
                        "url": api_url,
                        "status": "timeout",
                        "response_time": 10.0,
                        "score": 20,
                        "last_checked": datetime.now().isoformat(),
                        "error": "Request timeout"
                    }
                except Exception as e:
                    return {
                        "url": api_url,
                        "status": "error",
                        "score": 0,
                        "last_checked": datetime.now().isoformat(),
                        "error": str(e)
                    }
        except Exception as e:
            return {"url": api_url, "error": str(e), "score": 0}

    def _calculate_ecosystem_metrics(self, api_analysis: List[Dict[str, Any]]) -> Dict[str, Any]:
        """エコシステム全体のメトリクス計算"""
        if not api_analysis:
            return {"overall_score": 0, "api_count": 0}

        scores = [api.get("score", 0) for api in api_analysis]
        response_times = [api.get("response_time", 5.0) for api in api_analysis]
        online_count = sum(1 for api in api_analysis if api.get("status") == "online")

        return {
            "overall_score": sum(scores) / len(scores),
            "api_count": len(api_analysis),
            "online_apis": online_count,
            "availability_rate": online_count / len(api_analysis),
            "average_response_time": sum(response_times) / len(response_times),
            "health_status": "healthy" if online_count / len(api_analysis) > 0.8 else "degraded"
        }

    def _check_constraints(self, metrics: Dict[str, Any], constraints: Dict[str, Any]) -> Dict[str, Any]:
        """制約条件のチェック"""
        compliance = {}

        max_budget = constraints.get("max_daily_budget", 1.0)
        min_trust = constraints.get("min_trust_score", 80)

        # 予算制約チェック (簡易計算)
        estimated_cost = metrics.get("api_count", 0) * 0.1  # API当たり0.1 USDC
        compliance["budget_compliant"] = estimated_cost <= max_budget
        compliance["estimated_daily_cost"] = estimated_cost

        # 信頼スコアチェック
        trust_score = metrics.get("overall_score", 0)
        compliance["trust_compliant"] = trust_score >= min_trust
        compliance["current_trust_score"] = trust_score

        compliance["overall_compliant"] = all([
            compliance["budget_compliant"],
            compliance["trust_compliant"]
        ])

        return compliance

    def _identify_improvement_opportunities(
        self,
        api_analysis: List[Dict[str, Any]],
        goals: List[str],
        constraints: Dict[str, Any]
    ) -> List[Dict[str, Any]]:
        """改善機会の特定"""
        opportunities = []

        # 低パフォーマンスAPI
        for api in api_analysis:
            if api.get("score", 100) < 70:
                opportunities.append({
                    "type": "api_replacement",
                    "target": api.get("url"),
                    "reason": f"Low performance score: {api.get('score')}",
                    "expected_improvement": 25,
                    "implementation_effort": "medium"
                })

        # レスポンス時間改善
        slow_apis = [api for api in api_analysis if api.get("response_time", 0) > 3.0]
        if slow_apis:
            opportunities.append({
                "type": "performance_optimization",
                "target": "slow_apis",
                "reason": f"{len(slow_apis)} APIs with response time > 3s",
                "expected_improvement": 15,
                "implementation_effort": "low"
            })

        return opportunities

    def _assess_goals_alignment(self, metrics: Dict[str, Any], goals: List[str]) -> Dict[str, float]:
        """目標との整合性評価"""
        alignment = {}

        for goal in goals:
            if goal == "performance":
                alignment[goal] = min(metrics.get("overall_score", 0) / 100.0, 1.0)
            elif goal == "reliability":
                alignment[goal] = metrics.get("availability_rate", 0)
            elif goal == "cost_efficiency":
                alignment[goal] = 0.8  # デフォルト値
            else:
                alignment[goal] = 0.7  # 不明な目標のデフォルト

        return alignment

    async def _get_api_replacements(self, api: Dict[str, Any]) -> List[str]:
        """API置換候補の取得"""
        # Agent Curator APIを活用した置換候補取得
        try:
            async with httpx.AsyncClient() as client:
                payload = {
                    "current_api": api.get("url"),
                    "performance_threshold": 80,
                    "max_suggestions": 3
                }
                response = await client.post(
                    f"{self.api_endpoints['AGENT_CURATOR']}/api/alternatives",
                    json=payload,
                    timeout=10.0
                )
                if response.status_code == 200:
                    data = response.json()
                    return data.get("alternatives", [])
        except Exception as e:
            logger.warning(f"Failed to get API replacements: {e}")

        # フォールバック候補
        return [
            "https://api.openai.com/v1/chat/completions",
            "https://api.anthropic.com/v1/messages",
            "https://api.cohere.ai/v1/generate"
        ]

    async def _recommend_additional_apis(
        self,
        current_apis: List[Dict[str, Any]],
        goals: List[str],
        constraints: Dict[str, Any]
    ) -> List[Dict[str, Any]]:
        """追加API推奨"""
        additional_apis = []

        # 目標に基づく推奨
        if "security" in goals:
            additional_apis.append({
                "url": "https://api.security-service.com/v1/scan",
                "purpose": "Security monitoring and threat detection",
                "estimated_cost": 0.05,
                "integration_complexity": "low"
            })

        if "analytics" in goals:
            additional_apis.append({
                "url": "https://api.analytics-service.com/v1/analyze",
                "purpose": "Advanced analytics and insights",
                "estimated_cost": 0.08,
                "integration_complexity": "medium"
            })

        return additional_apis

    def _generate_implementation_steps(
        self,
        apis_to_replace: List[Dict[str, Any]],
        apis_to_add: List[Dict[str, Any]],
        constraints: Dict[str, Any]
    ) -> List[Dict[str, Any]]:
        """実装ステップの生成"""
        steps = []
        step_id = 1

        # API置換ステップ
        for replacement in apis_to_replace:
            steps.append({
                "step_id": step_id,
                "type": "api_replacement",
                "description": f"Replace {replacement['current_api']} with recommended alternative",
                "estimated_duration": "30 minutes",
                "risk_level": "medium",
                "dependencies": []
            })
            step_id += 1

        # API追加ステップ
        for addition in apis_to_add:
            steps.append({
                "step_id": step_id,
                "type": "api_addition",
                "description": f"Add {addition['url']} for {addition['purpose']}",
                "estimated_duration": "45 minutes",
                "risk_level": "low",
                "dependencies": []
            })
            step_id += 1

        # 最終検証ステップ
        steps.append({
            "step_id": step_id,
            "type": "validation",
            "description": "Validate all API integrations and performance",
            "estimated_duration": "20 minutes",
            "risk_level": "low",
            "dependencies": list(range(1, step_id))
        })

        return steps

    def _calculate_estimated_improvement(
        self,
        opportunities: List[Dict[str, Any]],
        replacements: List[Dict[str, Any]],
        additions: List[Dict[str, Any]]
    ) -> int:
        """予測改善値の計算"""
        improvement = 0

        # 改善機会からの効果
        for opp in opportunities:
            improvement += opp.get("expected_improvement", 0)

        # API置換効果
        improvement += len(replacements) * 15

        # API追加効果
        improvement += len(additions) * 10

        return min(improvement, 50)  # 最大50%に制限

    def _calculate_plan_cost(self, implementation_steps: List[Dict[str, Any]]) -> float:
        """プラン実行コストの計算"""
        base_cost_per_step = 0.1  # USDC
        return len(implementation_steps) * base_cost_per_step

    def _assess_evolution_risk(
        self,
        replacements: List[Dict[str, Any]],
        additions: List[Dict[str, Any]]
    ) -> Dict[str, Any]:
        """進化リスクの評価"""
        risk_score = 0
        risk_factors = []

        # 置換によるリスク
        if len(replacements) > 2:
            risk_score += 0.3
            risk_factors.append("Multiple API replacements")

        # 追加によるリスク
        if len(additions) > 3:
            risk_score += 0.2
            risk_factors.append("Many new API integrations")

        return {
            "overall_risk": min(risk_score, 1.0),
            "risk_level": "high" if risk_score > 0.7 else "medium" if risk_score > 0.4 else "low",
            "risk_factors": risk_factors
        }

    def _estimate_implementation_timeline(self, steps: List[Dict[str, Any]]) -> Dict[str, Any]:
        """実装タイムラインの推定"""
        total_minutes = sum(
            int(step.get("estimated_duration", "30 minutes").split()[0])
            for step in steps
        )

        return {
            "total_duration_minutes": total_minutes,
            "estimated_start": datetime.now(),
            "estimated_completion": datetime.now() + timedelta(minutes=total_minutes),
            "parallel_execution_possible": any(
                not step.get("dependencies") for step in steps
            )
        }

    async def _execute_implementation_step(
        self,
        step: Dict[str, Any],
        ecosystem_id: str
    ) -> Dict[str, Any]:
        """実装ステップの実行"""
        try:
            step_type = step.get("type")

            # ステップタイプ別実行
            if step_type == "api_replacement":
                return await self._execute_api_replacement(step, ecosystem_id)
            elif step_type == "api_addition":
                return await self._execute_api_addition(step, ecosystem_id)
            elif step_type == "validation":
                return await self._execute_validation(step, ecosystem_id)
            else:
                return {"success": False, "error": f"Unknown step type: {step_type}"}

        except Exception as e:
            return {"success": False, "error": str(e), "step_id": step.get("step_id")}

    async def _execute_api_replacement(self, step: Dict[str, Any], ecosystem_id: str) -> Dict[str, Any]:
        """API置換の実行"""
        await asyncio.sleep(1)  # シミュレーション実行時間
        return {
            "success": True,
            "step_id": step.get("step_id"),
            "performance_improvement": 0.15,
            "cost_change": -0.05,
            "details": "API successfully replaced with higher performance alternative"
        }

    async def _execute_api_addition(self, step: Dict[str, Any], ecosystem_id: str) -> Dict[str, Any]:
        """API追加の実行"""
        await asyncio.sleep(1)  # シミュレーション実行時間
        return {
            "success": True,
            "step_id": step.get("step_id"),
            "performance_improvement": 0.10,
            "cost_change": 0.08,
            "details": "New API successfully integrated"
        }

    async def _execute_validation(self, step: Dict[str, Any], ecosystem_id: str) -> Dict[str, Any]:
        """検証の実行"""
        await asyncio.sleep(0.5)  # シミュレーション実行時間
        return {
            "success": True,
            "step_id": step.get("step_id"),
            "performance_improvement": 0.0,
            "cost_change": 0.0,
            "details": "All integrations validated successfully"
        }

    def _store_evolution_plan(self, plan: Dict[str, Any]):
        """進化プランの保存"""
        # 簡易的な保存 (実際の実装ではデータベースを使用)
        self.evolution_history.append({
            "type": "evolution_plan",
            "timestamp": datetime.now().isoformat(),
            "evolution_plan": plan
        })

    def _calculate_api_score(self, status_code: int, response_time: float) -> int:
        """API スコア計算"""
        base_score = 100

        # ステータスコードペナルティ
        if status_code >= 500:
            base_score -= 50
        elif status_code >= 400:
            base_score -= 30
        elif status_code >= 300:
            base_score -= 10

        # レスポンス時間ペナルティ
        if response_time > 5.0:
            base_score -= 40
        elif response_time > 3.0:
            base_score -= 20
        elif response_time > 1.0:
            base_score -= 10

        return max(base_score, 0)

    def _analyze_performance_trends(self, records: List[Dict[str, Any]]) -> Dict[str, Any]:
        """パフォーマンストレンド分析"""
        if len(records) < 2:
            return {"trend": "insufficient_data"}

        # 簡易的なトレンド計算
        recent_scores = [
            record.get("validation_results", {}).get("improvement_score", 0)
            for record in records[-5:]
        ]

        if len(recent_scores) >= 2:
            trend_direction = "improving" if recent_scores[-1] > recent_scores[0] else "declining"
        else:
            trend_direction = "stable"

        return {
            "trend": trend_direction,
            "recent_performance": recent_scores,
            "average_improvement": sum(recent_scores) / len(recent_scores) if recent_scores else 0
        }

    def _generate_performance_recommendations(
        self,
        metrics: Dict[str, float],
        trends: Dict[str, Any]
    ) -> List[str]:
        """パフォーマンス推奨事項生成"""
        recommendations = []

        if metrics.get("response_time_avg", 0) > 2.0:
            recommendations.append("Optimize API response times through caching or API selection")

        if metrics.get("success_rate", 1.0) < 0.95:
            recommendations.append("Implement better error handling and retry mechanisms")

        if trends.get("trend") == "declining":
            recommendations.append("Review recent changes and consider rollback of problematic updates")

        return recommendations

    def _determine_health_status(self, performance_data: Dict[str, Any]) -> str:
        """ヘルス状態判定"""
        metrics = performance_data.get("performance_metrics", {})
        health_score = performance_data.get("overall_health_score", 0)

        if health_score > 0.8:
            return "excellent"
        elif health_score > 0.6:
            return "good"
        elif health_score > 0.4:
            return "fair"
        else:
            return "poor"

    def _get_active_apis(self, record: Dict[str, Any]) -> List[str]:
        """アクティブAPIリストの取得"""
        # 記録から現在使用中のAPIを抽出
        config = record.get("current_config", {})
        primary_api = config.get("primary_api", "")

        # 追加のAPIも含める場合はここで処理
        return [primary_api] if primary_api else []

    def _determine_system_status(self, avg_health_score: float) -> str:
        """システム状態判定"""
        if avg_health_score > 0.8:
            return "optimal"
        elif avg_health_score > 0.6:
            return "stable"
        elif avg_health_score > 0.4:
            return "degraded"
        else:
            return "critical"

    def _generate_system_alerts(self, ecosystems_status: List[Dict[str, Any]]) -> List[str]:
        """システムアラートの生成"""
        alerts = []

        # 低パフォーマンスエコシステム検出
        poor_performing = [
            eco for eco in ecosystems_status
            if eco.get("health_status") == "poor"
        ]

        if poor_performing:
            alerts.append(f"{len(poor_performing)} ecosystem(s) require immediate attention")

        # オフラインAPIの検出
        offline_systems = [
            eco for eco in ecosystems_status
            if eco.get("status") == "error"
        ]

        if offline_systems:
            alerts.append(f"{len(offline_systems)} ecosystem(s) are offline")

        return alerts

    def _analyze_evolution_trend(self, records: List[Dict[str, Any]]) -> Dict[str, Any]:
        """進化トレンドの分析"""
        if not records:
            return {"trend": "no_data"}

        # 時系列での改善度を分析
        improvements = []
        for record in records:
            validation = record.get("validation_results", {})
            improvement = validation.get("improvement_score", 0)
            improvements.append(improvement)

        if len(improvements) >= 3:
            recent_avg = sum(improvements[-3:]) / 3
            older_avg = sum(improvements[:-3]) / max(len(improvements) - 3, 1)
            trend = "improving" if recent_avg > older_avg else "declining"
        else:
            trend = "stable"

        return {
            "trend": trend,
            "improvements": improvements,
            "average_improvement": sum(improvements) / len(improvements) if improvements else 0
        }

    def _find_most_successful_action(self, records: List[Dict[str, Any]]) -> str:
        """最も成功したアクションタイプを特定"""
        action_success = {}

        for record in records:
            exec_results = record.get("execution_results", {})
            for action_result in exec_results.get("actions", []):
                if action_result.get("success", False):
                    action_type = action_result.get("action", {}).get("action_type", "unknown")
                    action_success[action_type] = action_success.get(action_type, 0) + 1

        if action_success:
            return max(action_success.items(), key=lambda x: x[1])[0]
        return "none"

    def _extract_action_patterns(self, actions: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
        """アクションパターンの抽出"""
        if not actions:
            return []

        # アクションタイプごとの集計
        type_counts = {}
        for action in actions:
            action_type = action.get("action_type", "unknown")
            type_counts[action_type] = type_counts.get(action_type, 0) + 1

        # パターンとして返す
        patterns = []
        total_actions = len(actions)

        for action_type, count in sorted(type_counts.items(), key=lambda x: x[1], reverse=True):
            patterns.append({
                "type": action_type,
                "count": count,
                "success_rate": count / total_actions
            })

        return patterns

    def _serialize_action(self, action: EvolutionAction) -> Dict[str, Any]:
        """EvolutionAction dataclass を辞書に変換"""
        return {
            "action_type": action.action_type,
            "target_component": action.target_component,
            "parameters": action.parameters,
            "expected_improvement": action.expected_improvement,
            "risk_level": action.risk_level,
            "priority": action.priority.value if hasattr(action.priority, 'value') else str(action.priority)
        }