369 lines
11 KiB
Python
369 lines
11 KiB
Python
#!/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测试中断")
|