@agentunion/kite 1.5.0 → 1.6.0

package/extensions/services/model_service/module.md

@@ -1,17 +1,26 @@
 ---
 name: model_service
-display_name: Model Service
+display_name: 模型服务
 version: '1.0'
 type: service
-state: manual
+state: enabled
+max_connections: 3
 runtime: python
 entry: entry.py
+businesses:
+- name: model_service
+  type: llm_service
+  description: 大模型服务配置
+  config_file: config.json5
 events:
 - model_service.test
 subscriptions:
 - module.started
 - module.stopped
 - module.shutdown
+monitor: true
+preferred_port: null
+advertise_ip: 127.0.0.1
 ---
 # Model Service（大模型服务）
 

package/extensions/services/proxy/aid_manager.py

@@ -0,0 +1,419 @@
+"""
+AID 生命周期管理
+
+从 userPresenter 提取的 AID 逻辑：
+- AgentCP 实例创建
+- AID 获取/创建/上线/重建
+- 断线回调
+"""
+
+import asyncio
+import os
+import random
+import threading
+import time
+import traceback
+from pathlib import Path
+
+
+class AIDManager:
+    """管理 AgentID 的完整生命周期"""
+
+    def __init__(self, auth_bridge, config_store):
+        self._auth_bridge = auth_bridge
+        self._config_store = config_store
+        self._lock = threading.RLock()
+        self._agentcp_instance = None
+        self._agentcp_lock = threading.RLock()
+
+        self.agentId = None
+        self._aid_initializing = False
+
+        # 重建控制
+        self._rebuild_lock = threading.Lock()
+        self._rebuild_in_progress = False
+        self._last_rebuild_time = 0
+        self._rebuild_cooldown = 1800  # 30分钟
+
+        # 连续无响应计数
+        self._no_response_count = 0
+        self._no_response_threshold = 10
+        self._no_response_lock = threading.Lock()
+
+        # AgentCP 工作目录
+        module_data = os.environ.get("KITE_MODULE_DATA", "")
+        self._agentcp_dir = os.path.join(module_data, "agentcp") if module_data else ""
+
+        # evol_agentId_online 回调
+        self._on_aid_online_callback = None
+
+    def set_on_aid_online(self, callback):
+        """设置 AID 上线后的回调"""
+        self._on_aid_online_callback = callback
+
+    def _get_agentcp_instance(self):
+        """获取持久化的 AgentCP 实例"""
+        with self._agentcp_lock:
+            if self._agentcp_instance is None:
+                from agentcp import AgentCP
+
+                agentcp_dir = Path(self._agentcp_dir)
+                agentcp_dir.mkdir(parents=True, exist_ok=True)
+
+                self._agentcp_instance = AgentCP(
+                    agentcp_dir,
+                    seed_password="evol_user_default_password",
+                    debug=False,
+                    run_proxy=False,
+                )
+            return self._agentcp_instance
+
+    async def initialize(self):
+        """初始化 AID（异步入口）"""
+        try:
+            evol_token = await self._auth_bridge.get_evol_token()
+            if not evol_token:
+                print("[aid_manager] 无法获取 evol_token，AID 初始化延迟")
+                return False
+
+            return await self._user_agent_login(evol_token)
+
+        except Exception as e:
+            print(f"[aid_manager] AID 初始化失败: {e}")
+            traceback.print_exc()
+            return False
+
+    async def _user_agent_login(self, evol_token: str) -> bool:
+        """用户 AID 登录流程"""
+        try:
+            print("[aid_manager] 开始 AID 登录流程")
+
+            aid_info = await self._get_user_aid_info()
+
+            if aid_info is None:
+                print("[aid_manager] 服务器未返回 AID，创建新 AID")
+                return await self._create_and_sync_aid()
+
+            aid_id = aid_info.get("aid")
+            if not aid_id:
+                print("[aid_manager] AID 信息无效，创建新 AID")
+                return await self._create_and_sync_aid()
+
+            print(f"[aid_manager] 服务器返回 AID: {aid_id}")
+            return await self._handle_existing_aid(aid_id)
+
+        except Exception as e:
+            print(f"[aid_manager] AID 登录异常: {e}")
+            traceback.print_exc()
+            return False
+
+    async def _get_user_aid_info(self) -> dict | None:
+        """获取用户 AID 信息（通过 auth_bridge RPC）"""
+        try:
+            return await self._auth_bridge.get_user_aid()
+        except Exception as e:
+            print(f"[aid_manager] 获取 AID 信息异常: {e}")
+            return None
+
+    async def _get_user_aid_detail(self) -> dict | None:
+        """获取用户 AID 详细信息（通过 auth_bridge RPC）"""
+        try:
+            return await self._auth_bridge.get_user_aid_detail()
+        except Exception as e:
+            print(f"[aid_manager] 获取 AID 详细信息异常: {e}")
+            return None
+
+    async def _create_and_sync_aid(self) -> bool:
+        """创建 AID 并同步到服务器"""
+        try:
+            timestamp = int(time.time())
+            random_num = random.randint(0, 9)
+            agent_name = f"evol_{timestamp}_{random_num}"
+
+            agentcp = self._get_agentcp_instance()
+            aid = await asyncio.to_thread(agentcp.create_aid, "aid.pub", agent_name)
+
+            if aid is None:
+                print("[aid_manager] 创建 AID 失败")
+                return False
+
+            print(f"[aid_manager] 创建新 AID: {aid.id}")
+
+            # 读取密钥
+            private_key = agentcp.read_private_key(aid.id)
+            pem_str = agentcp.read_certificate_pem(aid.id)
+
+            # 同步到服务器
+            sync_data = {"aid": aid.id, "privateKey": private_key, "pemStr": pem_str}
+            sync_ok = await self._submit_aid_info(sync_data)
+            if not sync_ok:
+                return False
+
+            print(f"[aid_manager] AID 已同步到服务器: {aid.id}")
+
+            # 上线
+            await asyncio.to_thread(aid.online)
+
+            if aid.is_online_success:
+                self._set_agent_id(aid)
+                self._register_disconnect_callback(aid)
+                print(f"[aid_manager] AID 上线成功: {aid.id}")
+                return True
+            else:
+                print("[aid_manager] AID 上线失败")
+                return False
+
+        except Exception as e:
+            print(f"[aid_manager] 创建 AID 失败: {e}")
+            traceback.print_exc()
+            return False
+
+    async def _handle_existing_aid(self, aid_id: str) -> bool:
+        """处理已存在的 AID"""
+        try:
+            if self.agentId is not None and self.agentId.id == aid_id:
+                print(f"[aid_manager] 当前已加载正确的 AID: {aid_id}")
+                return True
+
+            agentcp = self._get_agentcp_instance()
+            loaded = await asyncio.to_thread(agentcp.load_aid, aid_id)
+
+            if loaded is None:
+                print(f"[aid_manager] 本地未找到 AID: {aid_id}，从服务器同步")
+                return await self._sync_aid_from_server(aid_id)
+
+            await asyncio.to_thread(loaded.online)
+
+            if loaded.is_online_success:
+                self._set_agent_id(loaded)
+                self._register_disconnect_callback(loaded)
+                print(f"[aid_manager] AID 登录成功: {aid_id}")
+                return True
+            else:
+                print("[aid_manager] AID 上线失败")
+                return False
+
+        except Exception as e:
+            print(f"[aid_manager] 处理现有 AID 失败: {e}")
+            traceback.print_exc()
+            return False
+
+    async def _sync_aid_from_server(self, aid_id: str) -> bool:
+        """从服务器同步 AID 数据到本地"""
+        try:
+            detail = await self._get_user_aid_detail()
+            if not detail or detail.get("aid") != aid_id:
+                print("[aid_manager] 从服务器获取 AID 详细信息失败")
+                return False
+
+            agentcp = self._get_agentcp_instance()
+
+            try:
+                agentcp.get_guest_aid("aud.pub")
+            except Exception:
+                pass
+
+            agentcp.save_aid_info(
+                aid_id,
+                "evol_user_default_password",
+                detail.get("privateKey", ""),
+                detail.get("pemStr", ""),
+            )
+
+            loaded = await asyncio.to_thread(agentcp.load_aid, aid_id)
+            if loaded is None:
+                return False
+
+            await asyncio.to_thread(loaded.online)
+
+            if loaded.is_online_success:
+                self._set_agent_id(loaded)
+                self._register_disconnect_callback(loaded)
+                print(f"[aid_manager] AID 同步并登录成功: {aid_id}")
+                return True
+            else:
+                print("[aid_manager] 同步的 AID 上线失败")
+                return False
+
+        except Exception as e:
+            print(f"[aid_manager] 同步 AID 失败: {e}")
+            traceback.print_exc()
+            return False
+
+    async def _submit_aid_info(self, aid_data: dict) -> bool:
+        """提交 AID 信息到服务器（通过 auth_bridge RPC）"""
+        try:
+            return await self._auth_bridge.submit_user_aid(
+                aid_data.get("aid", ""),
+                aid_data.get("privateKey", ""),
+                aid_data.get("pemStr", "")
+            )
+        except Exception as e:
+            print(f"[aid_manager] AID 信息同步异常: {e}")
+            return False
+
+    def _set_agent_id(self, aid):
+        """设置当前 AgentID 并触发回调"""
+        with self._lock:
+            self.agentId = aid
+
+        # 触发 agentIdPresenter 注册
+        if aid.is_online_success and self._on_aid_online_callback:
+            try:
+                self._on_aid_online_callback(aid)
+            except Exception as e:
+                print(f"[aid_manager] AID 上线回调失败: {e}")
+
+    def _register_disconnect_callback(self, aid):
+        """注册断线回调"""
+        try:
+            aid.set_disconnect_callback(self._on_disconnect)
+        except Exception as e:
+            print(f"[aid_manager] 注册断线回调失败: {e}")
+
+    def _on_disconnect(self, *args, **kwargs):
+        """AgentCP 断线回调"""
+        print("[aid_manager] AgentID 断线，触发重建...")
+        try:
+            self.full_rebuild_sync()
+        except Exception as e:
+            print(f"[aid_manager] 断线重建失败: {e}")
+
+    def full_rebuild_sync(self) -> bool:
+        """同步重建 AgentCP（用于断线回调）"""
+        with self._rebuild_lock:
+            if self._rebuild_in_progress:
+                return False
+            self._rebuild_in_progress = True
+
+        try:
+            # 检查冷却
+            elapsed = time.time() - self._last_rebuild_time
+            if elapsed < self._rebuild_cooldown:
+                remaining = (self._rebuild_cooldown - elapsed) / 60
+                print(f"[aid_manager] 重建冷却中，剩余 {remaining:.1f} 分钟")
+                return False
+
+            self._last_rebuild_time = time.time()
+
+            # 尝试重新上线
+            with self._lock:
+                current = self.agentId
+
+            if current is not None:
+                print(f"[aid_manager] 尝试重新上线: {current.id}")
+                current.online()
+
+                if current.is_online_success:
+                    self._set_agent_id(current)
+                    self._register_disconnect_callback(current)
+                    print(f"[aid_manager] 重建成功: {current.id}")
+                    return True
+
+            # 从本地加载 AID
+            print("[aid_manager] 尝试从本地加载 AID...")
+            agentcp_dir = Path(self._agentcp_dir)
+            aids_dir = agentcp_dir / "agentcp" / "AIDs"
+            if not aids_dir.exists():
+                print("[aid_manager] 无本地 AID 数据")
+                return False
+
+            aid_dirs = [d for d in aids_dir.iterdir() if d.is_dir()]
+            if not aid_dirs:
+                return False
+
+            from agentcp import AgentCP
+            new_agentcp = AgentCP(agentcp_dir, seed_password="evol_user_default_password", debug=False, run_proxy=False)
+            new_aid = new_agentcp.load_aid(aid_dirs[0].name)
+
+            if new_aid is None:
+                return False
+
+            new_aid.online()
+
+            if new_aid.is_online_success:
+                with self._agentcp_lock:
+                    self._agentcp_instance = new_agentcp
+                self._set_agent_id(new_aid)
+                self._register_disconnect_callback(new_aid)
+                print(f"[aid_manager] 完全重建成功: {new_aid.id}")
+                return True
+
+            return False
+
+        except Exception as e:
+            print(f"[aid_manager] 重建异常: {e}")
+            traceback.print_exc()
+            return False
+        finally:
+            with self._rebuild_lock:
+                self._rebuild_in_progress = False
+
+    async def force_rebuild(self, bypass_cooldown: bool = True) -> dict:
+        """异步强制重建"""
+        with self._rebuild_lock:
+            if self._rebuild_in_progress:
+                return {"success": False, "message": "重建已在进行中"}
+            self._rebuild_in_progress = True
+
+        try:
+            if not bypass_cooldown:
+                elapsed = time.time() - self._last_rebuild_time
+                if elapsed < self._rebuild_cooldown:
+                    remaining = (self._rebuild_cooldown - elapsed) / 60
+                    return {"success": False, "message": f"冷却中，剩余 {remaining:.1f} 分钟"}
+
+            self._last_rebuild_time = time.time()
+
+            with self._lock:
+                current = self.agentId
+
+            if current is not None:
+                await asyncio.to_thread(current.online)
+
+                if current.is_online_success:
+                    self._set_agent_id(current)
+                    self._register_disconnect_callback(current)
+                    return {"success": True, "message": "重建成功", "agent_id": current.id}
+
+            # 完全重建
+            result = await asyncio.to_thread(self.full_rebuild_sync)
+            agent_id = self.agentId.id if self.agentId else None
+            return {"success": result, "message": "完全重建" + ("成功" if result else "失败"), "agent_id": agent_id}
+
+        except Exception as e:
+            return {"success": False, "message": f"重建异常: {e}"}
+        finally:
+            with self._rebuild_lock:
+                self._rebuild_in_progress = False
+
+    # 连续无响应计数
+
+    def increment_no_response(self) -> int:
+        with self._no_response_lock:
+            self._no_response_count += 1
+            return self._no_response_count
+
+    def reset_no_response(self):
+        with self._no_response_lock:
+            self._no_response_count = 0
+
+    def should_trigger_rebuild(self) -> bool:
+        with self._no_response_lock:
+            return self._no_response_count >= self._no_response_threshold
+
+    async def shutdown(self):
+        """优雅关闭"""
+        print("[aid_manager] 开始关闭...")
+        with self._lock:
+            aid = self.agentId
+            self.agentId = None
+
+        if aid is not None:
+            try:
+                await asyncio.to_thread(aid.offline)
+                print(f"[aid_manager] AID 已下线: {aid.id}")
+            except Exception as e:
+                print(f"[aid_manager] AID 下线失败: {e}")
+
+        print("[aid_manager] 关闭完成")

package/extensions/services/proxy/auth_bridge.py

@@ -0,0 +1,182 @@
+"""
+认证桥接模块
+
+通过 Kernel RPC 调用 evol.list_evol_tokens 获取 evol_token。
+带缓存和 TTL 自动刷新。
+"""
+
+import asyncio
+import time
+import threading
+
+
+class AuthBridge:
+    """跨模块 RPC 调用 Evol 获取认证信息"""
+
+    def __init__(self):
+        self._evol_token = None
+        self._evol_token_time = 0
+        self._evol_token_ttl = 6 * 3600  # 6小时
+        self._user_info = None
+        self._lock = threading.Lock()
+        self._rpc_call = None  # 由 ProxyServer 注入
+        self._evol_ready = False
+
+    def set_rpc_caller(self, rpc_call_fn):
+        """注入 RPC 调用函数（由 ProxyServer 提供）"""
+        self._rpc_call = rpc_call_fn
+
+    def set_evol_ready(self, ready: bool = True):
+        """标记 Evol 模块已就绪"""
+        self._evol_ready = ready
+        if ready:
+            print("[auth_bridge] Evol 模块已就绪")
+
+    async def get_evol_token(self) -> str | None:
+        """获取 evol_token（带缓存）"""
+        with self._lock:
+            now = time.time()
+            if self._evol_token and (now - self._evol_token_time) < self._evol_token_ttl:
+                return self._evol_token
+
+        # 缓存过期或没有，从 Evol 获取
+        token = await self._fetch_evol_token()
+        if token:
+            with self._lock:
+                self._evol_token = token
+                self._evol_token_time = time.time()
+        return token
+
+    async def _fetch_evol_token(self) -> str | None:
+        """通过 RPC 获取 evol_token"""
+        if not self._rpc_call:
+            print("[auth_bridge] RPC 调用函数未设置")
+            return None
+
+        if not self._evol_ready:
+            print("[auth_bridge] Evol 模块尚未就绪")
+            return None
+
+        try:
+            result = await self._rpc_call("evol.list_evol_tokens", timeout=10.0)
+            tokens = result.get("tokens", [])
+            if not tokens:
+                print("[auth_bridge] Evol 未返回任何 token")
+                return None
+
+            # 取第一个有效 token
+            first = tokens[0]
+            token = first.get("token", "")
+            phone = first.get("phone", "")
+            if token:
+                print(f"[auth_bridge] 获取 evol_token 成功 (phone: {phone[:3]}****)")
+                # 缓存用户信息
+                with self._lock:
+                    self._user_info = first
+                return token
+            return None
+
+        except Exception as e:
+            print(f"[auth_bridge] 获取 evol_token 失败: {e}")
+            return None
+
+    async def refresh_token(self):
+        """强制刷新 token"""
+        with self._lock:
+            self._evol_token = None
+            self._evol_token_time = 0
+        return await self.get_evol_token()
+
+    def invalidate(self):
+        """清除 token 缓存（用户登出时调用）"""
+        with self._lock:
+            self._evol_token = None
+            self._evol_token_time = 0
+            self._user_info = None
+        print("[auth_bridge] Token 缓存已清除（用户登出）")
+
+    def get_cached_user_info(self) -> dict | None:
+        """获取缓存的用户信息"""
+        with self._lock:
+            return self._user_info
+
+    def is_logged_in(self) -> bool:
+        """检查是否已获取到 evol_token"""
+        with self._lock:
+            return self._evol_token is not None
+
+    def get_cached_token(self) -> str | None:
+        """同步获取缓存的 token（不触发 RPC）"""
+        with self._lock:
+            if self._evol_token and (time.time() - self._evol_token_time) < self._evol_token_ttl:
+                return self._evol_token
+            return None
+
+    async def get_user_aid(self) -> dict | None:
+        """获取用户 AID 基本信息"""
+        evol_token = await self.get_evol_token()
+        if not evol_token:
+            return None
+
+        try:
+            result = await self._rpc_call("evol.get_user_aid", {"evol_token": evol_token}, timeout=10.0)
+            if result.get("success"):
+                return result.get("data")
+            else:
+                print(f"[auth_bridge] 获取 AID 信息失败: {result.get('msg')}")
+                return None
+        except Exception as e:
+            print(f"[auth_bridge] 获取 AID 信息异常: {e}")
+            return None
+
+    async def get_user_aid_detail(self) -> dict | None:
+        """获取用户 AID 详细信息（含私钥/证书）"""
+        evol_token = await self.get_evol_token()
+        if not evol_token:
+            return None
+
+        try:
+            result = await self._rpc_call("evol.get_user_aid_detail", {"evol_token": evol_token}, timeout=10.0)
+            if result.get("success"):
+                return result.get("data")
+            else:
+                print(f"[auth_bridge] 获取 AID 详细信息失败: {result.get('msg')}")
+                return None
+        except Exception as e:
+            print(f"[auth_bridge] 获取 AID 详细信息异常: {e}")
+            return None
+
+    async def submit_user_aid(self, aid: str, private_key: str, pem_str: str) -> bool:
+        """提交用户 AID 信息到服务器"""
+        evol_token = await self.get_evol_token()
+        if not evol_token:
+            return False
+
+        try:
+            result = await self._rpc_call("evol.submit_user_aid", {
+                "evol_token": evol_token,
+                "aid": aid,
+                "privateKey": private_key,
+                "pemStr": pem_str,
+            }, timeout=10.0)
+            return result.get("success", False)
+        except Exception as e:
+            print(f"[auth_bridge] 提交 AID 信息异常: {e}")
+            return False
+
+    async def get_api_keys(self) -> list:
+        """获取用户的 API Key 列表"""
+        evol_token = await self.get_evol_token()
+        if not evol_token:
+            return []
+
+        try:
+            result = await self._rpc_call("evol.get_api_keys", {"evol_token": evol_token}, timeout=10.0)
+            if result.get("success"):
+                return result.get("data", [])
+            else:
+                print(f"[auth_bridge] 获取 API Keys 失败: {result.get('msg')}")
+                return []
+        except Exception as e:
+            print(f"[auth_bridge] 获取 API Keys 异常: {e}")
+            return []