Uni Agent

"""
UniAgent 协议适配器

支持的协议:
- ANP: Agent Network Protocol (去中心化身份 + Agent 网络)
- MCP: Model Context Protocol (LLM 工具调用)
- A2A: Agent-to-Agent (Google Agent 间协作)
- AITP: Agent Interaction & Transaction Protocol (交互 + 交易)
- Agent Protocol: 统一 REST API
- LMOS: Language Model OS (企业级 Agent 平台)
"""

from .base import ProtocolAdapter, Connection, AgentInfo
from .anp import ANPAdapter
from .mcp import MCPAdapter
from .a2a import A2AAdapter
from .aitp import AITPAdapter
from .agent_protocol import AgentProtocolAdapter
from .lmos import LMOSAdapter

ADAPTERS = {
    "anp": ANPAdapter,
    "mcp": MCPAdapter,
    "a2a": A2AAdapter,
    "aitp": AITPAdapter,
    "agent_protocol": AgentProtocolAdapter,
    "ap": AgentProtocolAdapter,
    "lmos": LMOSAdapter,
}

def get_adapter(protocol: str) -> ProtocolAdapter:
    """获取协议适配器"""
    adapter_class = ADAPTERS.get(protocol)
    if not adapter_class:
        raise ValueError(f"不支持的协议: {protocol}，可用协议: {list(ADAPTERS.keys())}")
    return adapter_class()

def register_adapter(protocol: str, adapter_class: type):
    """注册新的协议适配器"""
    ADAPTERS[protocol] = adapter_class

def list_protocols() -> list:
    """列出所有支持的协议"""
    return list(set(ADAPTERS.keys()))

__all__ = [
    "ProtocolAdapter",
    "Connection",
    "AgentInfo",
    "ANPAdapter",
    "MCPAdapter",
    "A2AAdapter",
    "AITPAdapter",
    "AgentProtocolAdapter",
    "LMOSAdapter",
    "get_adapter",
    "register_adapter",
    "list_protocols",
    "ADAPTERS",
]

"""
A2A (Agent-to-Agent) 适配器
Google 提出的 Agent 间协作协议

参考: https://github.com/google/a2a
"""

import json
import uuid
from pathlib import Path
from typing import Any, Dict, List, Optional

import aiohttp

from .base import ProtocolAdapter, Connection, AgentInfo


class A2AAdapter(ProtocolAdapter):
    """A2A 协议适配器"""
    
    protocol_name = "a2a"
    
    def __init__(self, config_dir: Optional[Path] = None):
        self.config_dir = config_dir or Path(__file__).parent.parent / "config"
        self._agent_cards: Dict[str, dict] = {}
    
    async def _fetch_agent_card(self, endpoint: str) -> dict:
        """获取 Agent Card"""
        if endpoint in self._agent_cards:
            return self._agent_cards[endpoint]
        
        agent_json_url = endpoint.rstrip("/")
        if not agent_json_url.endswith("agent.json"):
            agent_json_url = f"{agent_json_url}/.well-known/agent.json"
        
        async with aiohttp.ClientSession() as session:
            async with session.get(agent_json_url, timeout=aiohttp.ClientTimeout(total=15)) as resp:
                if resp.status == 200:
                    card = await resp.json()
                    self._agent_cards[endpoint] = card
                    return card
                raise Exception(f"获取 Agent Card 失败: HTTP {resp.status}")
    
    async def connect(self, agent_config: dict) -> Connection:
        """建立连接"""
        endpoint = agent_config.get("endpoint")
        if not endpoint:
            raise ValueError("A2A Agent 配置必须包含 endpoint")
        
        agent_card = await self._fetch_agent_card(endpoint)
        
        rpc_url = None
        if "url" in agent_card:
            rpc_url = agent_card["url"]
        elif "capabilities" in agent_card:
            caps = agent_card.get("capabilities", {})
            if "streaming" in caps:
                rpc_url = caps.get("streaming", {}).get("streamingUrl")
        
        if not rpc_url:
            rpc_url = endpoint.rstrip("/") + "/rpc"
        
        return Connection(
            agent_id=agent_config.get("id", ""),
            protocol=self.protocol_name,
            endpoint=rpc_url,
            session=None,
            metadata={
                "agent_card": agent_card,
                "original_endpoint": endpoint,
                "auth": agent_config.get("auth", {}),
            }
        )
    
    async def call(
        self, 
        connection: Connection, 
        method: str, 
        params: dict,
        timeout: float = 30.0
    ) -> dict:
        """调用 A2A Agent 方法"""
        rpc_url = connection.endpoint
        auth_config = connection.metadata.get("auth", {})
        
        headers = {
            "Content-Type": "application/json",
        }
        
        if auth_config.get("type") == "api_key":
            headers["Authorization"] = f"Bearer {auth_config.get('api_key', '')}"
        elif auth_config.get("type") == "oauth2":
            token = await self._get_oauth_token(auth_config)
            headers["Authorization"] = f"Bearer {token}"
        
        task_id = str(uuid.uuid4())
        
        if method == "tasks/send":
            payload = {
                "jsonrpc": "2.0",
                "id": task_id,
                "method": "tasks/send",
                "params": {
                    "id": task_id,
                    "message": params.get("message", {}),
                }
            }
        elif method == "tasks/get":
            payload = {
                "jsonrpc": "2.0",
                "id": task_id,
                "method": "tasks/get",
                "params": {
                    "id": params.get("task_id", task_id),
                }
            }
        else:
            payload = {
                "jsonrpc": "2.0",
                "id": task_id,
                "method": method,
                "params": params,
            }
        
        async with aiohttp.ClientSession() as session:
            async with session.post(
                rpc_url,
                json=payload,
                headers=headers,
                timeout=aiohttp.ClientTimeout(total=timeout)
            ) as resp:
                if resp.status == 200:
                    result = await resp.json()
                    return {
                        "success": True,
                        "result": result.get("result", result),
                        "task_id": task_id,
                    }
                else:
                    error_text = await resp.text()
                    return {
                        "success": False,
                        "error": f"HTTP {resp.status}: {error_text}",
                    }
    
    async def _get_oauth_token(self, auth_config: dict) -> str:
        """获取 OAuth2 令牌"""
        token_url = auth_config.get("token_url")
        client_id = auth_config.get("client_id")
        client_secret = auth_config.get("client_secret")
        
        if not all([token_url, client_id, client_secret]):
            raise ValueError("OAuth2 配置不完整")
        
        async with aiohttp.ClientSession() as session:
            async with session.post(
                token_url,
                data={
                    "grant_type": "client_credentials",
                    "client_id": client_id,
                    "client_secret": client_secret,
                }
            ) as resp:
                if resp.status == 200:
                    result = await resp.json()
                    return result.get("access_token", "")
                raise Exception(f"获取 OAuth2 令牌失败: HTTP {resp.status}")
    
    async def discover(self, capability: str = "") -> List[AgentInfo]:
        """发现 Agent"""
        agents_file = self.config_dir / "agents.yaml"
        if not agents_file.exists():
            return []
        
        import yaml
        with open(agents_file) as f:
            config = yaml.safe_load(f)
        
        agents = []
        for agent in config.get("agents", []):
            if agent.get("protocol") != "a2a":
                continue
            
            if capability and capability.lower() not in agent.get("id", "").lower():
                continue
            
            agents.append(AgentInfo(
                id=f"{agent['id']}@a2a",
                protocol="a2a",
                name=agent.get("name", agent["id"]),
                endpoint=agent.get("endpoint", ""),
                metadata=agent
            ))
        
        return agents
    
    async def close(self, connection: Connection):
        """关闭连接"""
        pass
    
    async def get_methods(self, connection: Connection) -> List[dict]:
        """获取 Agent 支持的方法（从 Agent Card 的 skills）"""
        agent_card = connection.metadata.get("agent_card", {})
        skills = agent_card.get("skills", [])
        
        methods = []
        for skill in skills:
            methods.append({
                "name": skill.get("id", skill.get("name", "unknown")),
                "description": skill.get("description", ""),
                "inputSchema": skill.get("inputSchema", {}),
                "outputSchema": skill.get("outputSchema", {}),
            })
        
        methods.extend([
            {"name": "tasks/send", "description": "发送任务消息"},
            {"name": "tasks/get", "description": "获取任务状态"},
            {"name": "tasks/cancel", "description": "取消任务"},
        ])
        
        return methods
    
    def validate_config(self, agent_config: dict) -> bool:
        """验证配置"""
        return "endpoint" in agent_config

"""
Agent Protocol 适配器
AI Engineer Foundation 提出的 Agent 统一 REST API

参考: https://agentprotocol.ai
"""

import json
import uuid
from pathlib import Path
from typing import Any, Dict, List, Optional

import aiohttp

from .base import ProtocolAdapter, Connection, AgentInfo


class AgentProtocolAdapter(ProtocolAdapter):
    """Agent Protocol 适配器"""
    
    protocol_name = "agent_protocol"
    
    def __init__(self, config_dir: Optional[Path] = None):
        self.config_dir = config_dir or Path(__file__).parent.parent / "config"
        self._tasks: Dict[str, dict] = {}
    
    async def connect(self, agent_config: dict) -> Connection:
        """建立连接"""
        endpoint = agent_config.get("endpoint")
        if not endpoint:
            raise ValueError("Agent Protocol 配置必须包含 endpoint")
        
        endpoint = endpoint.rstrip("/")
        if not endpoint.endswith("/ap/v1"):
            endpoint = f"{endpoint}/ap/v1"
        
        return Connection(
            agent_id=agent_config.get("id", ""),
            protocol=self.protocol_name,
            endpoint=endpoint,
            session=None,
            metadata=agent_config
        )
    
    async def call(
        self, 
        connection: Connection, 
        method: str, 
        params: dict,
        timeout: float = 30.0
    ) -> dict:
        """调用 Agent Protocol API"""
        endpoint = connection.endpoint
        
        headers = {
            "Content-Type": "application/json",
        }
        
        api_key = connection.metadata.get("api_key")
        if api_key:
            headers["Authorization"] = f"Bearer {api_key}"
        
        if method == "create_task":
            async with aiohttp.ClientSession() as session:
                async with session.post(
                    f"{endpoint}/agent/tasks",
                    json={"input": params.get("input", "")},
                    headers=headers,
                    timeout=aiohttp.ClientTimeout(total=timeout)
                ) as resp:
                    if resp.status in [200, 201]:
                        result = await resp.json()
                        task_id = result.get("task_id")
                        self._tasks[task_id] = result
                        return {"success": True, "result": result, "task_id": task_id}
                    else:
                        return {"success": False, "error": f"HTTP {resp.status}"}
        
        elif method == "execute_step":
            task_id = params.get("task_id")
            if not task_id:
                return {"success": False, "error": "缺少 task_id"}
            
            async with aiohttp.ClientSession() as session:
                async with session.post(
                    f"{endpoint}/agent/tasks/{task_id}/steps",
                    json={"input": params.get("input", "")},
                    headers=headers,
                    timeout=aiohttp.ClientTimeout(total=timeout)
                ) as resp:
                    if resp.status in [200, 201]:
                        result = await resp.json()
                        return {"success": True, "result": result}
                    else:
                        return {"success": False, "error": f"HTTP {resp.status}"}
        
        elif method == "get_task":
            task_id = params.get("task_id")
            if not task_id:
                return {"success": False, "error": "缺少 task_id"}
            
            async with aiohttp.ClientSession() as session:
                async with session.get(
                    f"{endpoint}/agent/tasks/{task_id}",
                    headers=headers,
                    timeout=aiohttp.ClientTimeout(total=timeout)
                ) as resp:
                    if resp.status == 200:
                        result = await resp.json()
                        return {"success": True, "result": result}
                    else:
                        return {"success": False, "error": f"HTTP {resp.status}"}
        
        elif method == "list_tasks":
            async with aiohttp.ClientSession() as session:
                async with session.get(
                    f"{endpoint}/agent/tasks",
                    headers=headers,
                    timeout=aiohttp.ClientTimeout(total=timeout)
                ) as resp:
                    if resp.status == 200:
                        result = await resp.json()
                        return {"success": True, "result": result}
                    else:
                        return {"success": False, "error": f"HTTP {resp.status}"}
        
        elif method == "get_artifacts":
            task_id = params.get("task_id")
            if not task_id:
                return {"success": False, "error": "缺少 task_id"}
            
            async with aiohttp.ClientSession() as session:
                async with session.get(
                    f"{endpoint}/agent/tasks/{task_id}/artifacts",
                    headers=headers,
                    timeout=aiohttp.ClientTimeout(total=timeout)
                ) as resp:
                    if resp.status == 200:
                        result = await resp.json()
                        return {"success": True, "result": result}
                    else:
                        return {"success": False, "error": f"HTTP {resp.status}"}
        
        else:
            return {"success": False, "error": f"未知方法: {method}"}
    
    async def discover(self, capability: str = "") -> List[AgentInfo]:
        """发现 Agent"""
        agents_file = self.config_dir / "agents.yaml"
        if not agents_file.exists():
            return []
        
        import yaml
        with open(agents_file) as f:
            config = yaml.safe_load(f)
        
        agents = []
        for agent in config.get("agents", []):
            if agent.get("protocol") != "agent_protocol":
                continue
            
            if capability and capability.lower() not in agent.get("id", "").lower():
                continue
            
            agents.append(AgentInfo(
                id=f"{agent['id']}@agent_protocol",
                protocol="agent_protocol",
                name=agent.get("name", agent["id"]),
                endpoint=agent.get("endpoint", ""),
                metadata=agent
            ))
        
        return agents
    
    async def close(self, connection: Connection):
        """关闭连接"""
        pass
    
    async def get_methods(self, connection: Connection) -> List[dict]:
        """获取支持的方法"""
        return [
            {
                "name": "create_task",
                "description": "创建新任务",
                "inputSchema": {"input": "string"},
            },
            {
                "name": "execute_step",
                "description": "执行任务步骤",
                "inputSchema": {"task_id": "string", "input": "string"},
            },
            {
                "name": "get_task",
                "description": "获取任务状态",
                "inputSchema": {"task_id": "string"},
            },
            {
                "name": "list_tasks",
                "description": "列出所有任务",
                "inputSchema": {},
            },
            {
                "name": "get_artifacts",
                "description": "获取任务产物",
                "inputSchema": {"task_id": "string"},
            },
        ]
    
    def validate_config(self, agent_config: dict) -> bool:
        """验证配置"""
        return "endpoint" in agent_config

"""
AITP (Agent Interaction & Transaction Protocol) 适配器
NEAR 基金会提出的 Agent 交互与交易协议

参考: https://aitp.dev
"""

import json
import uuid
from pathlib import Path
from typing import Any, Dict, List, Optional

import aiohttp

from .base import ProtocolAdapter, Connection, AgentInfo


class AITPAdapter(ProtocolAdapter):
    """AITP 协议适配器"""
    
    protocol_name = "aitp"
    
    def __init__(self, config_dir: Optional[Path] = None):
        self.config_dir = config_dir or Path(__file__).parent.parent / "config"
        self._threads: Dict[str, dict] = {}
    
    async def connect(self, agent_config: dict) -> Connection:
        """建立连接 - 创建 Thread"""
        endpoint = agent_config.get("endpoint")
        if not endpoint:
            raise ValueError("AITP Agent 配置必须包含 endpoint")
        
        thread_id = str(uuid.uuid4())
        
        self._threads[thread_id] = {
            "id": thread_id,
            "messages": [],
            "status": "open",
        }
        
        return Connection(
            agent_id=agent_config.get("id", ""),
            protocol=self.protocol_name,
            endpoint=endpoint,
            session=thread_id,
            metadata={
                "thread_id": thread_id,
                "wallet": agent_config.get("wallet", {}),
            }
        )
    
    async def call(
        self, 
        connection: Connection, 
        method: str, 
        params: dict,
        timeout: float = 30.0
    ) -> dict:
        """调用 AITP Agent"""
        endpoint = connection.endpoint
        thread_id = connection.session
        wallet_config = connection.metadata.get("wallet", {})
        
        headers = {
            "Content-Type": "application/json",
        }
        
        if method == "message":
            payload = {
                "thread_id": thread_id,
                "message": {
                    "role": "user",
                    "content": params.get("content", ""),
                    "parts": params.get("parts", []),
                }
            }
        elif method == "payment":
            payload = {
                "thread_id": thread_id,
                "capability": "aitp-01",
                "payment_request": {
                    "amount": params.get("amount"),
                    "currency": params.get("currency", "NEAR"),
                    "recipient": params.get("recipient"),
                    "memo": params.get("memo", ""),
                }
            }
            
            if wallet_config.get("type") == "near":
                payload["wallet"] = {
                    "type": "near",
                    "account_id": wallet_config.get("account_id"),
                }
        elif method == "decision":
            payload = {
                "thread_id": thread_id,
                "capability": "aitp-02",
                "decision_request": {
                    "question": params.get("question"),
                    "options": params.get("options", []),
                    "allow_custom": params.get("allow_custom", False),
                }
            }
        elif method == "data_request":
            payload = {
                "thread_id": thread_id,
                "capability": "aitp-03",
                "data_request": {
                    "schema": params.get("schema", {}),
                    "description": params.get("description", ""),
                }
            }
        else:
            payload = {
                "thread_id": thread_id,
                "method": method,
                "params": params,
            }
        
        async with aiohttp.ClientSession() as session:
            async with session.post(
                f"{endpoint}/threads/{thread_id}/messages",
                json=payload,
                headers=headers,
                timeout=aiohttp.ClientTimeout(total=timeout)
            ) as resp:
                if resp.status == 200:
                    result = await resp.json()
                    
                    if thread_id in self._threads:
                        self._threads[thread_id]["messages"].append(payload)
                        self._threads[thread_id]["messages"].append(result)
                    
                    return {
                        "success": True,
                        "result": result,
                        "thread_id": thread_id,
                    }
                else:
                    error_text = await resp.text()
                    return {
                        "success": False,
                        "error": f"HTTP {resp.status}: {error_text}",
                    }
    
    async def discover(self, capability: str = "") -> List[AgentInfo]:
        """发现 Agent"""
        agents_file = self.config_dir / "agents.yaml"
        if not agents_file.exists():
            return []
        
        import yaml
        with open(agents_file) as f:
            config = yaml.safe_load(f)
        
        agents = []
        for agent in config.get("agents", []):
            if agent.get("protocol") != "aitp":
                continue
            
            if capability and capability.lower() not in agent.get("id", "").lower():
                continue
            
            agents.append(AgentInfo(
                id=f"{agent['id']}@aitp",
                protocol="aitp",
                name=agent.get("name", agent["id"]),
                endpoint=agent.get("endpoint", ""),
                metadata=agent
            ))
        
        return agents
    
    async def close(self, connection: Connection):
        """关闭连接 - 关闭 Thread"""
        thread_id = connection.session
        if thread_id in self._threads:
            self._threads[thread_id]["status"] = "closed"
    
    async def get_methods(self, connection: Connection) -> List[dict]:
        """获取支持的方法（AITP 能力）"""
        return [
            {
                "name": "message",
                "description": "发送对话消息",
                "inputSchema": {"content": "string"},
            },
            {
                "name": "payment",
                "description": "AITP-01: 发起支付请求",
                "inputSchema": {
                    "amount": "number",
                    "currency": "string",
                    "recipient": "string",
                },
            },
            {
                "name": "decision",
                "description": "AITP-02: 请求用户决策",
                "inputSchema": {
                    "question": "string",
                    "options": "array",
                },
            },
            {
                "name": "data_request",
                "description": "AITP-03: 请求结构化数据",
                "inputSchema": {
                    "schema": "object",
                    "description": "string",
                },
            },
        ]
    
    def validate_config(self, agent_config: dict) -> bool:
        """验证配置"""
        return "endpoint" in agent_config

"""
ANP (Agent Network Protocol) 适配器
"""

import json
from pathlib import Path
from typing import Any, Dict, List, Optional

import aiohttp

from .base import ProtocolAdapter, Connection, AgentInfo

try:
    from anp.anp_crawler import ANPCrawler
    HAS_ANP = True
except ImportError:
    HAS_ANP = False


class ANPAdapter(ProtocolAdapter):
    """ANP 协议适配器"""
    
    protocol_name = "anp"
    
    def __init__(self, config_dir: Optional[Path] = None):
        self.config_dir = config_dir or Path(__file__).parent.parent / "config"
        self._crawler = None
        self._ad_cache: Dict[str, dict] = {}
        self._endpoint_cache: Dict[str, str] = {}
    
    def _get_crawler(self) -> "ANPCrawler":
        """获取 ANP Crawler 实例"""
        if not HAS_ANP:
            raise ImportError("请安装 anp 库: pip install anp")
        
        if self._crawler is None:
            did_path = self.config_dir / "did.json"
            key_path = self.config_dir / "private-key.pem"
            
            if did_path.exists() and key_path.exists():
                self._crawler = ANPCrawler(
                    did_document_path=str(did_path),
                    private_key_path=str(key_path)
                )
            else:
                raise FileNotFoundError(
                    f"DID 配置文件不存在: {did_path} 或 {key_path}\n"
                    "请运行 setup.sh 生成本地身份"
                )
        
        return self._crawler
    
    async def _fetch_ad(self, ad_url: str) -> dict:
        """获取 Agent Description 文档"""
        if ad_url in self._ad_cache:
            return self._ad_cache[ad_url]
        
        async with aiohttp.ClientSession() as session:
            async with session.get(ad_url, timeout=aiohttp.ClientTimeout(total=15)) as resp:
                if resp.status == 200:
                    ad = await resp.json()
                    self._ad_cache[ad_url] = ad
                    return ad
                raise Exception(f"获取 AD 失败: HTTP {resp.status}")
    
    async def _get_endpoint(self, ad_url: str) -> str:
        """从 AD 获取 RPC 端点"""
        if ad_url in self._endpoint_cache:
            return self._endpoint_cache[ad_url]
        
        ad = await self._fetch_ad(ad_url)
        interfaces = ad.get("interfaces", [])
        
        if not interfaces:
            raise ValueError(f"AD 中没有定义接口: {ad_url}")
        
        interface_url = interfaces[0].get("url")
        if not interface_url:
            raise ValueError(f"接口 URL 为空: {ad_url}")
        
        async with aiohttp.ClientSession() as session:
            async with session.get(interface_url, timeout=aiohttp.ClientTimeout(total=15)) as resp:
                if resp.status == 200:
                    interface_doc = await resp.json()
                    servers = interface_doc.get("servers", [])
                    if servers:
                        endpoint = servers[0].get("url")
                        self._endpoint_cache[ad_url] = endpoint
                        return endpoint
        
        raise ValueError(f"无法获取 RPC 端点: {ad_url}")
    
    async def connect(self, agent_config: dict) -> Connection:
        """建立连接"""
        ad_url = agent_config.get("ad_url")
        if not ad_url:
            raise ValueError("ANP Agent 配置必须包含 ad_url")
        
        ad = await self._fetch_ad(ad_url)
        endpoint = await self._get_endpoint(ad_url)
        
        return Connection(
            agent_id=agent_config.get("id", ""),
            protocol=self.protocol_name,
            endpoint=endpoint,
            session=self._get_crawler(),
            metadata={
                "ad_url": ad_url,
                "ad": ad,
                "name": ad.get("name", ""),
            }
        )
    
    async def call(
        self, 
        connection: Connection, 
        method: str, 
        params: dict,
        timeout: float = 30.0
    ) -> dict:
        """调用 Agent 方法"""
        crawler = connection.session
        endpoint = connection.endpoint
        
        result = await crawler.execute_json_rpc(
            endpoint=endpoint,
            method=method,
            params=params
        )
        
        return result
    
    async def discover(self, capability: str = "") -> List[AgentInfo]:
        """发现 Agent（从本地配置）"""
        agents_file = self.config_dir / "agents.yaml"
        if not agents_file.exists():
            return []
        
        import yaml
        with open(agents_file) as f:
            config = yaml.safe_load(f)
        
        agents = []
        for agent in config.get("agents", []):
            if agent.get("protocol") != "anp":
                continue
            
            if capability and capability.lower() not in agent.get("id", "").lower():
                continue
            
            agents.append(AgentInfo(
                id=f"{agent['id']}@anp",
                protocol="anp",
                name=agent.get("name", agent["id"]),
                endpoint=agent.get("ad_url", ""),
                metadata=agent
            ))
        
        return agents
    
    async def close(self, connection: Connection):
        """关闭连接"""
        pass
    
    async def get_methods(self, connection: Connection) -> List[dict]:
        """获取 Agent 支持的方法"""
        ad_url = connection.metadata.get("ad_url")
        if not ad_url:
            return []
        
        ad = await self._fetch_ad(ad_url)
        interfaces = ad.get("interfaces", [])
        
        if not interfaces:
            return []
        
        interface_url = interfaces[0].get("url")
        if not interface_url:
            return []
        
        async with aiohttp.ClientSession() as session:
            async with session.get(interface_url, timeout=aiohttp.ClientTimeout(total=15)) as resp:
                if resp.status == 200:
                    interface_doc = await resp.json()
                    return interface_doc.get("methods", [])
        
        return []
    
    def validate_config(self, agent_config: dict) -> bool:
        """验证配置"""
        return "ad_url" in agent_config

"""
协议适配器基类
"""

from abc import ABC, abstractmethod
from dataclasses import dataclass, field
from typing import Any, Dict, List, Optional


@dataclass
class AgentInfo:
    """Agent 信息"""
    id: str
    protocol: str
    name: str = ""
    description: str = ""
    methods: List[str] = field(default_factory=list)
    endpoint: str = ""
    metadata: Dict[str, Any] = field(default_factory=dict)


@dataclass
class Connection:
    """连接对象"""
    agent_id: str
    protocol: str
    endpoint: str = ""
    session: Any = None
    metadata: Dict[str, Any] = field(default_factory=dict)
    
    def is_active(self) -> bool:
        return self.session is not None


class ProtocolAdapter(ABC):
    """协议适配器基类"""
    
    protocol_name: str = "base"
    
    @abstractmethod
    async def connect(self, agent_config: dict) -> Connection:
        """
        建立与 Agent 的连接
        
        Args:
            agent_config: Agent 配置信息
            
        Returns:
            Connection 对象
        """
        pass
    
    @abstractmethod
    async def call(
        self, 
        connection: Connection, 
        method: str, 
        params: dict,
        timeout: float = 30.0
    ) -> dict:
        """
        调用 Agent 方法
        
        Args:
            connection: 连接对象
            method: 方法名
            params: 参数
            timeout: 超时时间（秒）
            
        Returns:
            调用结果
        """
        pass
    
    @abstractmethod
    async def discover(self, capability: str = "") -> List[AgentInfo]:
        """
        发现 Agent
        
        Args:
            capability: 能力关键词（可选）
            
        Returns:
            Agent 信息列表
        """
        pass
    
    @abstractmethod
    async def close(self, connection: Connection):
        """
        关闭连接
        
        Args:
            connection: 连接对象
        """
        pass
    
    async def get_methods(self, connection: Connection) -> List[dict]:
        """
        获取 Agent 支持的方法列表
        
        Args:
            connection: 连接对象
            
        Returns:
            方法列表
        """
        return []
    
    def validate_config(self, agent_config: dict) -> bool:
        """
        验证 Agent 配置
        
        Args:
            agent_config: Agent 配置
            
        Returns:
            是否有效
        """
        return True

"""
LMOS (Language Model Operating System) 适配器
Eclipse 基金会孵化的企业级多 Agent 平台

参考: https://eclipse.dev/lmos/
"""

import json
import uuid
from pathlib import Path
from typing import Any, Dict, List, Optional

import aiohttp

from .base import ProtocolAdapter, Connection, AgentInfo


class LMOSAdapter(ProtocolAdapter):
    """LMOS 协议适配器"""
    
    protocol_name = "lmos"
    
    def __init__(self, config_dir: Optional[Path] = None):
        self.config_dir = config_dir or Path(__file__).parent.parent / "config"
        self._registry_cache: Dict[str, List[dict]] = {}
    
    async def _discover_via_mdns(self) -> List[dict]:
        """通过 mDNS 发现本地 Agent（简化实现）"""
        return []
    
    async def _query_registry(self, registry_url: str, capability: str = "") -> List[dict]:
        """查询 Agent 注册中心"""
        if registry_url in self._registry_cache:
            return self._registry_cache[registry_url]
        
        async with aiohttp.ClientSession() as session:
            params = {}
            if capability:
                params["capability"] = capability
            
            async with session.get(
                f"{registry_url}/agents",
                params=params,
                timeout=aiohttp.ClientTimeout(total=15)
            ) as resp:
                if resp.status == 200:
                    result = await resp.json()
                    agents = result.get("agents", [])
                    self._registry_cache[registry_url] = agents
                    return agents
                return []
    
    async def connect(self, agent_config: dict) -> Connection:
        """建立连接"""
        endpoint = agent_config.get("endpoint")
        registry_url = agent_config.get("registry_url")
        
        if not endpoint and not registry_url:
            raise ValueError("LMOS Agent 配置必须包含 endpoint 或 registry_url")
        
        if registry_url and not endpoint:
            agent_id = agent_config.get("id")
            agents = await self._query_registry(registry_url)
            for agent in agents:
                if agent.get("id") == agent_id:
                    endpoint = agent.get("endpoint")
                    break
            
            if not endpoint:
                raise ValueError(f"在注册中心未找到 Agent: {agent_id}")
        
        return Connection(
            agent_id=agent_config.get("id", ""),
            protocol=self.protocol_name,
            endpoint=endpoint,
            session=None,
            metadata={
                "registry_url": registry_url,
                "group": agent_config.get("group"),
            }
        )
    
    async def call(
        self, 
        connection: Connection, 
        method: str, 
        params: dict,
        timeout: float = 30.0
    ) -> dict:
        """调用 LMOS Agent"""
        endpoint = connection.endpoint
        
        headers = {
            "Content-Type": "application/json",
        }
        
        if method == "invoke":
            payload = {
                "capability": params.get("capability"),
                "input": params.get("input", {}),
                "context": params.get("context", {}),
            }
        elif method == "route":
            payload = {
                "query": params.get("query"),
                "context": params.get("context", {}),
            }
        elif method == "describe":
            async with aiohttp.ClientSession() as session:
                async with session.get(
                    f"{endpoint}/capabilities",
                    headers=headers,
                    timeout=aiohttp.ClientTimeout(total=timeout)
                ) as resp:
                    if resp.status == 200:
                        result = await resp.json()
                        return {"success": True, "result": result}
                    else:
                        return {"success": False, "error": f"HTTP {resp.status}"}
        else:
            payload = {
                "method": method,
                "params": params,
            }
        
        async with aiohttp.ClientSession() as session:
            async with session.post(
                f"{endpoint}/invoke",
                json=payload,
                headers=headers,
                timeout=aiohttp.ClientTimeout(total=timeout)
            ) as resp:
                if resp.status == 200:
                    result = await resp.json()
                    return {"success": True, "result": result}
                else:
                    error_text = await resp.text()
                    return {"success": False, "error": f"HTTP {resp.status}: {error_text}"}
    
    async def discover(self, capability: str = "") -> List[AgentInfo]:
        """发现 Agent"""
        agents_file = self.config_dir / "agents.yaml"
        if not agents_file.exists():
            return []
        
        import yaml
        with open(agents_file) as f:
            config = yaml.safe_load(f)
        
        all_agents = []
        
        for agent in config.get("agents", []):
            if agent.get("protocol") != "lmos":
                continue
            
            if capability and capability.lower() not in agent.get("id", "").lower():
                continue
            
            all_agents.append(AgentInfo(
                id=f"{agent['id']}@lmos",
                protocol="lmos",
                name=agent.get("name", agent["id"]),
                endpoint=agent.get("endpoint", ""),
                metadata=agent
            ))
        
        for agent in config.get("agents", []):
            if agent.get("protocol") != "lmos":
                continue
            
            registry_url = agent.get("registry_url")
            if registry_url:
                try:
                    remote_agents = await self._query_registry(registry_url, capability)
                    for ra in remote_agents:
                        all_agents.append(AgentInfo(
                            id=f"{ra['id']}@lmos",
                            protocol="lmos",
                            name=ra.get("name", ra["id"]),
                            endpoint=ra.get("endpoint", ""),
                            metadata=ra
                        ))
                except Exception:
                    pass
        
        return all_agents
    
    async def close(self, connection: Connection):
        """关闭连接"""
        pass
    
    async def get_methods(self, connection: Connection) -> List[dict]:
        """获取支持的方法"""
        result = await self.call(connection, "describe", {})
        
        if result.get("success"):
            capabilities = result.get("result", {}).get("capabilities", [])
            return [
                {
                    "name": cap.get("id", cap.get("name")),
                    "description": cap.get("description", ""),
                    "inputSchema": cap.get("inputSchema", {}),
                }
                for cap in capabilities
            ]
        
        return [
            {"name": "invoke", "description": "调用 Agent 能力"},
            {"name": "route", "description": "智能路由到最佳 Agent"},
            {"name": "describe", "description": "获取 Agent 能力描述"},
        ]
    
    def validate_config(self, agent_config: dict) -> bool:
        """验证配置"""
        return "endpoint" in agent_config or "registry_url" in agent_config

"""
MCP (Model Context Protocol) 适配器
"""

import asyncio
import json
import os
import subprocess
from pathlib import Path
from typing import Any, Dict, List, Optional

from .base import ProtocolAdapter, Connection, AgentInfo

try:
    from mcp import ClientSession, StdioServerParameters
    from mcp.client.stdio import stdio_client
    HAS_MCP = True
except ImportError:
    HAS_MCP = False


class MCPAdapter(ProtocolAdapter):
    """MCP 协议适配器"""
    
    protocol_name = "mcp"
    
    def __init__(self, config_dir: Optional[Path] = None):
        self.config_dir = config_dir or Path(__file__).parent.parent / "config"
        self._sessions: Dict[str, Any] = {}
    
    async def connect(self, agent_config: dict) -> Connection:
        """建立连接"""
        if not HAS_MCP:
            raise ImportError("请安装 mcp 库: pip install mcp")
        
        command = agent_config.get("command")
        args = agent_config.get("args", [])
        env = agent_config.get("env", {})
        
        if not command:
            raise ValueError("MCP Agent 配置必须包含 command")
        
        full_env = os.environ.copy()
        for k, v in env.items():
            if v.startswith("${") and v.endswith("}"):
                env_var = v[2:-1]
                full_env[k] = os.environ.get(env_var, "")
            else:
                full_env[k] = v
        
        server_params = StdioServerParameters(
            command=command,
            args=args,
            env=full_env
        )
        
        read, write = await stdio_client(server_params).__aenter__()
        session = ClientSession(read, write)
        await session.__aenter__()
        await session.initialize()
        
        agent_id = agent_config.get("id", "")
        self._sessions[agent_id] = {
            "session": session,
            "read": read,
            "write": write,
        }
        
        return Connection(
            agent_id=agent_id,
            protocol=self.protocol_name,
            endpoint=f"{command} {' '.join(args)}",
            session=session,
            metadata=agent_config
        )
    
    async def call(
        self, 
        connection: Connection, 
        method: str, 
        params: dict,
        timeout: float = 30.0
    ) -> dict:
        """调用 MCP 工具"""
        session: ClientSession = connection.session
        
        result = await asyncio.wait_for(
            session.call_tool(method, params),
            timeout=timeout
        )
        
        if hasattr(result, "content"):
            content = result.content
            if isinstance(content, list) and len(content) > 0:
                first = content[0]
                if hasattr(first, "text"):
                    return {"success": True, "result": first.text}
                return {"success": True, "result": str(first)}
            return {"success": True, "result": content}
        
        return {"success": True, "result": result}
    
    async def discover(self, capability: str = "") -> List[AgentInfo]:
        """发现 Agent（从本地配置）"""
        agents_file = self.config_dir / "agents.yaml"
        if not agents_file.exists():
            return []
        
        import yaml
        with open(agents_file) as f:
            config = yaml.safe_load(f)
        
        agents = []
        for agent in config.get("agents", []):
            if agent.get("protocol") != "mcp":
                continue
            
            if capability and capability.lower() not in agent.get("id", "").lower():
                continue
            
            agents.append(AgentInfo(
                id=f"{agent['id']}@mcp",
                protocol="mcp",
                name=agent.get("name", agent["id"]),
                endpoint=f"{agent.get('command', '')} {' '.join(agent.get('args', []))}",
                metadata=agent
            ))
        
        return agents
    
    async def close(self, connection: Connection):
        """关闭连接"""
        agent_id = connection.agent_id
        if agent_id in self._sessions:
            session_info = self._sessions.pop(agent_id)
            session = session_info.get("session")
            if session:
                await session.__aexit__(None, None, None)
    
    async def get_methods(self, connection: Connection) -> List[dict]:
        """获取 MCP Server 支持的工具"""
        session: ClientSession = connection.session
        
        result = await session.list_tools()
        
        tools = []
        if hasattr(result, "tools"):
            for tool in result.tools:
                tools.append({
                    "name": tool.name,
                    "description": getattr(tool, "description", ""),
                    "inputSchema": getattr(tool, "inputSchema", {}),
                })
        
        return tools
    
    def validate_config(self, agent_config: dict) -> bool:
        """验证配置"""
        return "command" in agent_config

# UniAgent 配置文件
# Agent 注册表

agents:
  # ==================== ANP Agents ====================
  - id: amap
    protocol: anp
    name: 高德地图
    ad_url: https://agent-connect.ai/mcp/agents/amap/ad.json
    description: 地点搜索、路线规划、天气查询、周边搜索

  - id: kuaidi
    protocol: anp
    name: 快递查询
    ad_url: https://agent-connect.ai/mcp/agents/kuaidi/ad.json
    description: 快递单号追踪

  - id: hotel
    protocol: anp
    name: 酒店预订
    ad_url: https://agent-connect.ai/agents/hotel-assistant/ad.json
    description: 搜索酒店、查询房价

  - id: juhe
    protocol: anp
    name: 聚合查询
    ad_url: https://agent-connect.ai/mcp/agents/juhe/ad.json
    description: 多种生活服务查询

  - id: navigation
    protocol: anp
    name: Agent导航
    ad_url: https://agent-search.ai/agents/navigation/ad.json
    description: 发现更多 ANP Agent

  # ==================== MCP Servers ====================
  # - id: filesystem
  #   protocol: mcp
  #   name: 文件系统
  #   command: npx
  #   args: ["-y", "@modelcontextprotocol/server-filesystem", "/tmp"]
  #   description: 文件读写操作

  # - id: github
  #   protocol: mcp
  #   name: GitHub
  #   command: npx
  #   args: ["-y", "@modelcontextprotocol/server-github"]
  #   env:
  #     GITHUB_TOKEN: "${GITHUB_TOKEN}"
  #   description: GitHub 仓库操作

  # - id: sqlite
  #   protocol: mcp
  #   name: SQLite
  #   command: npx
  #   args: ["-y", "@modelcontextprotocol/server-sqlite", "/tmp/test.db"]
  #   description: SQLite 数据库操作

  # ==================== A2A Agents ====================
  # Google Agent-to-Agent 协议
  # - id: gemini_assistant
  #   protocol: a2a
  #   name: Gemini Assistant
  #   endpoint: https://example.com/.well-known/agent.json
  #   auth:
  #     type: api_key
  #     api_key: "${A2A_API_KEY}"

  # - id: vertexai_agent
  #   protocol: a2a
  #   name: VertexAI Agent
  #   endpoint: https://your-project.cloudfunctions.net/agent
  #   auth:
  #     type: oauth2
  #     token_url: https://oauth2.googleapis.com/token
  #     client_id: "${GOOGLE_CLIENT_ID}"
  #     client_secret: "${GOOGLE_CLIENT_SECRET}"

  # ==================== AITP Agents ====================
  # NEAR Agent Interaction & Transaction Protocol
  # - id: near_shop
  #   protocol: aitp
  #   name: NEAR Shop
  #   endpoint: https://example.near.ai/api
  #   wallet:
  #     type: near
  #     account_id: "${NEAR_ACCOUNT_ID}"

  # - id: payment_agent
  #   protocol: aitp
  #   name: Payment Agent
  #   endpoint: https://pay.example.com/aitp
  #   description: 支持 NEAR/ETH 支付的 Agent

  # ==================== Agent Protocol ====================
  # AI Engineer Foundation REST API 标准
  # - id: autogpt
  #   protocol: agent_protocol
  #   name: AutoGPT
  #   endpoint: http://localhost:8000
  #   api_key: "${AUTOGPT_API_KEY}"

  # - id: smol_developer
  #   protocol: ap
  #   name: Smol Developer
  #   endpoint: http://localhost:8080

  # ==================== LMOS Agents ====================
  # Eclipse 企业级 Agent 平台
  # - id: customer_service
  #   protocol: lmos
  #   name: 客服 Agent
  #   registry_url: http://lmos-registry.internal:8080
  #   group: customer-agents

  # - id: sales_agent
  #   protocol: lmos
  #   name: 销售 Agent
  #   endpoint: http://sales-agent.internal:8080
  #   description: 处理销售咨询

# UniAgent 依赖

# 核心
pyyaml>=6.0
aiohttp>=3.8.0

# ANP 协议
anp>=0.1.0

# MCP 协议 (可选)
# mcp>=0.1.0

# A2A 协议 (待实现)
# google-a2a>=0.1.0

#!/usr/bin/env python3
"""
UniAgent 适配器测试脚本
测试所有协议适配器的基本功能
"""

import asyncio
import json
import sys
from pathlib import Path

sys.path.insert(0, str(Path(__file__).parent.parent))

from adapters import get_adapter, ADAPTERS, list_protocols


class TestResult:
    def __init__(self, protocol: str):
        self.protocol = protocol
        self.passed = 0
        self.failed = 0
        self.skipped = 0
        self.errors = []
    
    def pass_(self, msg: str):
        self.passed += 1
        print(f"  ✅ {msg}")
    
    def fail(self, msg: str, error: str = ""):
        self.failed += 1
        self.errors.append(f"{msg}: {error}")
        print(f"  ❌ {msg}: {error[:100]}")
    
    def skip(self, msg: str):
        self.skipped += 1
        print(f"  ⏭️  {msg} (跳过)")
    
    def summary(self) -> str:
        status = "✅" if self.failed == 0 else "❌"
        return f"{status} {self.protocol}: {self.passed} passed, {self.failed} failed, {self.skipped} skipped"


async def test_anp() -> TestResult:
    """测试 ANP 适配器"""
    result = TestResult("ANP")
    print("\n[ANP] 测试 Agent Network Protocol...\n")
    
    try:
        adapter = get_adapter("anp")
        result.pass_("获取适配器")
    except Exception as e:
        result.fail("获取适配器", str(e))
        return result
    
    agent_config = {
        "id": "amap",
        "protocol": "anp",
        "ad_url": "https://agent-connect.ai/mcp/agents/amap/ad.json"
    }
    
    try:
        connection = await adapter.connect(agent_config)
        result.pass_(f"建立连接: {connection.endpoint[:50]}...")
    except Exception as e:
        result.fail("建立连接", str(e))
        return result
    
    try:
        methods = await adapter.get_methods(connection)
        result.pass_(f"获取方法列表: {len(methods)} 个方法")
    except Exception as e:
        result.fail("获取方法列表", str(e))
    
    try:
        res = await adapter.call(connection, "maps_weather", {"city": "北京"})
        if res.get("success") or res.get("result"):
            city = res.get("result", {}).get("city", "")
            result.pass_(f"调用 maps_weather: {city}")
        else:
            result.fail("调用 maps_weather", str(res))
    except Exception as e:
        result.fail("调用 maps_weather", str(e))
    
    try:
        res = await adapter.call(connection, "maps_text_search", {"keywords": "咖啡厅", "city": "上海"})
        if res.get("success") or res.get("result"):
            pois = res.get("result", {}).get("pois", [])
            result.pass_(f"调用 maps_text_search: 找到 {len(pois)} 个结果")
        else:
            result.fail("调用 maps_text_search", str(res))
    except Exception as e:
        result.fail("调用 maps_text_search", str(e))
    
    try:
        agents = await adapter.discover()
        result.pass_(f"发现 Agent: {len(agents)} 个")
    except Exception as e:
        result.fail("发现 Agent", str(e))
    
    try:
        await adapter.close(connection)
        result.pass_("关闭连接")
    except Exception as e:
        result.fail("关闭连接", str(e))
    
    return result


async def test_mcp() -> TestResult:
    """测试 MCP 适配器"""
    result = TestResult("MCP")
    print("\n[MCP] 测试 Model Context Protocol...\n")
    
    try:
        adapter = get_adapter("mcp")
        result.pass_("获取适配器")
    except Exception as e:
        result.fail("获取适配器", str(e))
        return result
    
    result.skip("MCP 需要本地 npx 环境，跳过实际连接测试")
    result.skip("如需测试，请配置 config/agents.yaml 中的 MCP Server")
    
    return result


async def test_a2a() -> TestResult:
    """测试 A2A 适配器"""
    result = TestResult("A2A")
    print("\n[A2A] 测试 Agent-to-Agent Protocol...\n")
    
    try:
        adapter = get_adapter("a2a")
        result.pass_("获取适配器")
    except Exception as e:
        result.fail("获取适配器", str(e))
        return result
    
    result.skip("A2A 需要配置 Agent endpoint，跳过实际连接测试")
    result.skip("如需测试，请配置 config/agents.yaml 中的 A2A Agent")
    
    try:
        agents = await adapter.discover()
        result.pass_(f"发现 Agent: {len(agents)} 个 (本地配置)")
    except Exception as e:
        result.fail("发现 Agent", str(e))
    
    return result


async def test_aitp() -> TestResult:
    """测试 AITP 适配器"""
    result = TestResult("AITP")
    print("\n[AITP] 测试 Agent Interaction & Transaction Protocol...\n")
    
    try:
        adapter = get_adapter("aitp")
        result.pass_("获取适配器")
    except Exception as e:
        result.fail("获取适配器", str(e))
        return result
    
    result.skip("AITP 需要配置 NEAR 钱包和 endpoint，跳过实际连接测试")
    result.skip("如需测试，请配置 config/agents.yaml 中的 AITP Agent")
    
    try:
        agents = await adapter.discover()
        result.pass_(f"发现 Agent: {len(agents)} 个 (本地配置)")
    except Exception as e:
        result.fail("发现 Agent", str(e))
    
    try:
        methods = [
            {"name": "message", "desc": "发送消息"},
            {"name": "payment", "desc": "发起支付"},
            {"name": "decision", "desc": "请求决策"},
        ]
        result.pass_(f"支持方法: {', '.join([m['name'] for m in methods])}")
    except Exception as e:
        result.fail("检查方法", str(e))
    
    return result


async def test_agent_protocol() -> TestResult:
    """测试 Agent Protocol 适配器"""
    result = TestResult("Agent Protocol")
    print("\n[AP] 测试 Agent Protocol...\n")
    
    try:
        adapter = get_adapter("agent_protocol")
        result.pass_("获取适配器 (agent_protocol)")
    except Exception as e:
        result.fail("获取适配器", str(e))
        return result
    
    try:
        adapter2 = get_adapter("ap")
        result.pass_("获取适配器 (别名 ap)")
    except Exception as e:
        result.fail("获取适配器别名", str(e))
    
    result.skip("Agent Protocol 需要运行中的 Agent 服务，跳过实际连接测试")
    result.skip("如需测试，请启动 AutoGPT 或其他兼容服务")
    
    try:
        agents = await adapter.discover()
        result.pass_(f"发现 Agent: {len(agents)} 个 (本地配置)")
    except Exception as e:
        result.fail("发现 Agent", str(e))
    
    return result


async def test_lmos() -> TestResult:
    """测试 LMOS 适配器"""
    result = TestResult("LMOS")
    print("\n[LMOS] 测试 Language Model Operating System...\n")
    
    try:
        adapter = get_adapter("lmos")
        result.pass_("获取适配器")
    except Exception as e:
        result.fail("获取适配器", str(e))
        return result
    
    result.skip("LMOS 需要配置注册中心或 Agent endpoint，跳过实际连接测试")
    result.skip("如需测试，请配置 config/agents.yaml 中的 LMOS Agent")
    
    try:
        agents = await adapter.discover()
        result.pass_(f"发现 Agent: {len(agents)} 个 (本地配置)")
    except Exception as e:
        result.fail("发现 Agent", str(e))
    
    return result


async def main():
    print("=" * 60)
    print("  UniAgent 适配器测试")
    print("=" * 60)
    
    print(f"\n支持的协议: {list_protocols()}\n")
    
    results = []
    
    results.append(await test_anp())
    results.append(await test_mcp())
    results.append(await test_a2a())
    results.append(await test_aitp())
    results.append(await test_agent_protocol())
    results.append(await test_lmos())
    
    print("\n" + "=" * 60)
    print("  测试汇总")
    print("=" * 60 + "\n")
    
    total_passed = 0
    total_failed = 0
    total_skipped = 0
    
    for r in results:
        print(r.summary())
        total_passed += r.passed
        total_failed += r.failed
        total_skipped += r.skipped
    
    print(f"\n总计: {total_passed} passed, {total_failed} failed, {total_skipped} skipped")
    
    if total_failed > 0:
        print("\n失败详情:")
        for r in results:
            for err in r.errors:
                print(f"  - [{r.protocol}] {err}")
        sys.exit(1)
    else:
        print("\n🎉 所有测试通过！")


if __name__ == "__main__":
    asyncio.run(main())

#!/usr/bin/env python3
"""
UniAgent 完整测试脚本
启动测试服务器，测试所有协议的真实交互
"""

import asyncio
import json
import subprocess
import sys
import time
import signal
from pathlib import Path

sys.path.insert(0, str(Path(__file__).parent.parent))

from adapters import get_adapter


SERVERS = {}


def start_server(name: str, script: str, port: int) -> subprocess.Popen:
    """启动测试服务器"""
    script_path = Path(__file__).parent.parent / "test_servers" / script
    proc = subprocess.Popen(
        [sys.executable, str(script_path)],
        stdout=subprocess.PIPE,
        stderr=subprocess.PIPE,
    )
    time.sleep(0.5)
    if proc.poll() is not None:
        stderr = proc.stderr.read().decode()
        print(f"  ❌ {name} 启动失败: {stderr}")
        return None
    print(f"  ✅ {name} 启动成功 (port {port})")
    return proc


def stop_servers():
    """停止所有服务器"""
    for name, proc in SERVERS.items():
        if proc and proc.poll() is None:
            proc.terminate()
            proc.wait(timeout=2)


async def test_anp():
    """测试 ANP 适配器"""
    print("\n" + "=" * 50)
    print("[ANP] Agent Network Protocol")
    print("=" * 50)
    
    adapter = get_adapter("anp")
    config = {
        "id": "amap",
        "protocol": "anp",
        "ad_url": "https://agent-connect.ai/mcp/agents/amap/ad.json"
    }
    
    try:
        conn = await adapter.connect(config)
        print(f"✅ 连接成功: {conn.endpoint[:50]}...")
        
        result = await adapter.call(conn, "maps_weather", {"city": "北京"})
        city = result.get("result", {}).get("city", "")
        print(f"✅ maps_weather: {city}")
        
        result = await adapter.call(conn, "maps_text_search", {"keywords": "咖啡厅", "city": "上海"})
        pois = result.get("result", {}).get("pois", [])
        print(f"✅ maps_text_search: 找到 {len(pois)} 个结果")
        
        await adapter.close(conn)
        print(f"✅ 关闭连接")
        return True
    except Exception as e:
        print(f"❌ 测试失败: {e}")
        return False


async def test_a2a():
    """测试 A2A 适配器"""
    print("\n" + "=" * 50)
    print("[A2A] Agent-to-Agent Protocol")
    print("=" * 50)
    
    adapter = get_adapter("a2a")
    config = {
        "id": "test_agent",
        "protocol": "a2a",
        "endpoint": "http://localhost:8100"
    }
    
    try:
        conn = await adapter.connect(config)
        print(f"✅ 连接成功")
        
        methods = await adapter.get_methods(conn)
        print(f"✅ 获取方法: {len(methods)} 个 (包含 skills)")
        
        result = await adapter.call(conn, "tasks/send", {
            "message": {
                "role": "user",
                "parts": [{"type": "text", "text": "Hello A2A!"}]
            }
        })
        if result.get("success"):
            task = result.get("result", {})
            history = task.get("history", [])
            if len(history) >= 2:
                response = history[-1].get("parts", [{}])[0].get("text", "")
                print(f"✅ tasks/send: {response}")
            else:
                print(f"✅ tasks/send: 任务已创建")
        else:
            print(f"❌ tasks/send 失败: {result}")
            return False
        
        await adapter.close(conn)
        print(f"✅ 关闭连接")
        return True
    except Exception as e:
        print(f"❌ 测试失败: {e}")
        return False


async def test_aitp():
    """测试 AITP 适配器"""
    print("\n" + "=" * 50)
    print("[AITP] Agent Interaction & Transaction Protocol")
    print("=" * 50)
    
    adapter = get_adapter("aitp")
    config = {
        "id": "test_shop",
        "protocol": "aitp",
        "endpoint": "http://localhost:8101"
    }
    
    try:
        conn = await adapter.connect(config)
        print(f"✅ 连接成功 (Thread: {conn.session[:8]}...)")
        
        result = await adapter.call(conn, "message", {"content": "Hello AITP!"})
        if result.get("success"):
            response = result.get("result", {}).get("content", "")
            print(f"✅ message: {response}")
        else:
            print(f"❌ message 失败")
            return False
        
        result = await adapter.call(conn, "payment", {
            "amount": 10,
            "currency": "NEAR",
            "recipient": "shop.near"
        })
        if result.get("success"):
            payment = result.get("result", {}).get("payment_response", {})
            status = payment.get("status", "")
            tx_id = payment.get("transaction_id", "")[:8]
            print(f"✅ payment: {status} (tx: {tx_id}...)")
        else:
            print(f"❌ payment 失败")
            return False
        
        result = await adapter.call(conn, "decision", {
            "question": "选择颜色",
            "options": ["红色", "蓝色", "绿色"]
        })
        if result.get("success"):
            decision = result.get("result", {}).get("decision_response", {})
            selected = decision.get("selected", "")
            print(f"✅ decision: 选择了 {selected}")
        else:
            print(f"❌ decision 失败")
            return False
        
        await adapter.close(conn)
        print(f"✅ 关闭连接")
        return True
    except Exception as e:
        print(f"❌ 测试失败: {e}")
        return False


async def test_agent_protocol():
    """测试 Agent Protocol 适配器"""
    print("\n" + "=" * 50)
    print("[AP] Agent Protocol")
    print("=" * 50)
    
    adapter = get_adapter("agent_protocol")
    config = {
        "id": "test_agent",
        "protocol": "agent_protocol",
        "endpoint": "http://localhost:8102"
    }
    
    try:
        conn = await adapter.connect(config)
        print(f"✅ 连接成功")
        
        result = await adapter.call(conn, "create_task", {"input": "Hello Agent Protocol!"})
        if result.get("success"):
            task_id = result.get("task_id", "")
            print(f"✅ create_task: {task_id[:8]}...")
        else:
            print(f"❌ create_task 失败")
            return False
        
        result = await adapter.call(conn, "execute_step", {
            "task_id": task_id,
            "input": "Process this"
        })
        if result.get("success"):
            step = result.get("result", {})
            output = step.get("output", "")
            print(f"✅ execute_step: {output}")
        else:
            print(f"❌ execute_step 失败")
            return False
        
        result = await adapter.call(conn, "get_task", {"task_id": task_id})
        if result.get("success"):
            task = result.get("result", {})
            status = task.get("status", "")
            print(f"✅ get_task: status={status}")
        else:
            print(f"❌ get_task 失败")
            return False
        
        result = await adapter.call(conn, "get_artifacts", {"task_id": task_id})
        if result.get("success"):
            artifacts = result.get("result", {}).get("artifacts", [])
            print(f"✅ get_artifacts: {len(artifacts)} 个产物")
        else:
            print(f"❌ get_artifacts 失败")
            return False
        
        await adapter.close(conn)
        print(f"✅ 关闭连接")
        return True
    except Exception as e:
        print(f"❌ 测试失败: {e}")
        return False


async def test_lmos():
    """测试 LMOS 适配器"""
    print("\n" + "=" * 50)
    print("[LMOS] Language Model Operating System")
    print("=" * 50)
    
    adapter = get_adapter("lmos")
    config = {
        "id": "calculator",
        "protocol": "lmos",
        "endpoint": "http://localhost:8103/agents/calculator"
    }
    
    try:
        conn = await adapter.connect(config)
        print(f"✅ 连接成功")
        
        result = await adapter.call(conn, "invoke", {
            "capability": "add",
            "input": {"a": 10, "b": 20}
        })
        if result.get("success"):
            output = result.get("result", {}).get("output", {})
            calc_result = output.get("result", "")
            print(f"✅ invoke add(10, 20): {calc_result}")
        else:
            print(f"❌ invoke add 失败")
            return False
        
        result = await adapter.call(conn, "invoke", {
            "capability": "multiply",
            "input": {"a": 6, "b": 7}
        })
        if result.get("success"):
            output = result.get("result", {}).get("output", {})
            calc_result = output.get("result", "")
            print(f"✅ invoke multiply(6, 7): {calc_result}")
        else:
            print(f"❌ invoke multiply 失败")
            return False
        
        greeter_config = {
            "id": "greeter",
            "protocol": "lmos",
            "endpoint": "http://localhost:8103/agents/greeter"
        }
        conn2 = await adapter.connect(greeter_config)
        result = await adapter.call(conn2, "invoke", {
            "capability": "greet",
            "input": {"name": "test_user"}
        })
        if result.get("success"):
            output = result.get("result", {}).get("output", {})
            greeting = output.get("greeting", "")
            print(f"✅ invoke greet: {greeting}")
        else:
            print(f"❌ invoke greet 失败")
            return False
        
        await adapter.close(conn)
        await adapter.close(conn2)
        print(f"✅ 关闭连接")
        return True
    except Exception as e:
        print(f"❌ 测试失败: {e}")
        return False


async def main():
    print("=" * 60)
    print("  UniAgent 完整交互测试")
    print("=" * 60)
    
    print("\n[1] 启动测试服务器...")
    SERVERS["A2A"] = start_server("A2A Server", "a2a_server.py", 8100)
    SERVERS["AITP"] = start_server("AITP Server", "aitp_server.py", 8101)
    SERVERS["AP"] = start_server("Agent Protocol Server", "agent_protocol_server.py", 8102)
    SERVERS["LMOS"] = start_server("LMOS Server", "lmos_server.py", 8103)
    
    time.sleep(1)
    
    print("\n[2] 开始测试...")
    
    results = {}
    
    try:
        results["ANP"] = await test_anp()
        results["A2A"] = await test_a2a()
        results["AITP"] = await test_aitp()
        results["Agent Protocol"] = await test_agent_protocol()
        results["LMOS"] = await test_lmos()
    finally:
        print("\n[3] 停止测试服务器...")
        stop_servers()
        print("  ✅ 所有服务器已停止")
    
    print("\n" + "=" * 60)
    print("  测试汇总")
    print("=" * 60)
    
    all_passed = True
    for name, passed in results.items():
        status = "✅" if passed else "❌"
        print(f"  {status} {name}")
        if not passed:
            all_passed = False
    
    print()
    if all_passed:
        print("🎉 所有协议测试通过！")
    else:
        print("⚠️  部分测试失败")
        sys.exit(1)


if __name__ == "__main__":
    try:
        asyncio.run(main())
    except KeyboardInterrupt:
        stop_servers()
        print("\n测试中断")