@agentunion/kite 1.5.0 → 1.6.0

package/extensions/services/kite_console/relay_config.json5

@@ -0,0 +1,96 @@
+{
+  // 中转服务配置
+  relay: {
+    // 基础模块 ID（实际 module_id 会加上 session 后缀）
+    base_module_id: "kite_console-client",
+
+    // 重连超时时间（秒）
+    // 前端刷新页面或短暂断网时，中转服务保持 Kernel 连接的时长
+    reconnect_timeout: 6,
+
+    // WebSocket 端点路径
+    endpoint: "/ws/relay"
+  },
+
+  // 认证配置
+  auth: {
+    // frontend_token 有效期（秒，30天）
+    token_expiry: 2592000,
+
+    // token 续期阈值（秒，7天）
+    // 当 token 剩余有效期小于此值时，自动续期
+    token_renew_threshold: 604800,
+
+    // 配对码长度
+    pairing_code_length: 6,
+
+    // 配对码文件路径（相对于模块数据目录）
+    pairing_code_file: "pairing_codes.jsonl"
+  },
+
+  // 权限配置（基于角色的 RPC 白名单）
+  permissions: {
+    // 管理员角色 - 完全权限
+    admin: [
+      "event.*",              // 事件订阅（必需）
+      "registry.*",           // 注册表查询（必需）
+      "trace.*",              // 链路追踪查询
+      "launcher.*",           // 所有 launcher RPC
+      "kernel.health",        // Kernel 健康检查
+      "kernel.stats",         // Kernel 统计信息
+      "kernel.latencies",     // Kernel 延迟数据（ping 数据）
+      "kernel.get_module_events", // 模块事件信息查询
+      "kernel.get_registry_stats", // 注册中心统计数据
+      "kernel.connection_status",  // 模块连接槽位状态
+      "kernel.add_connection",       // 手动增加模块连接
+      "kernel.update_module_config", // 热更新模块多连接/多实例配置
+      "kernel.instance_pressure",    // 实例压力查询
+      "*.health",             // 所有模块的健康检查
+      "*.status",             // 所有模块的状态查询
+      "*.echo",               // 所有模块的 echo 测试
+      "*.get_info",           // 所有模块的信息查询
+      "*.get_status",         // 所有模块的状态查询（详细）
+      "*.nested_call",        // 所有模块的嵌套调用
+      "watchdog.*",           // Watchdog 相关
+      "backup.*",             // Backup 相关
+      "auth.*",               // Auth 认证模块（Token 管理等）
+      "model_service.*",      // Model Service 相关
+      "redis.*",              // Redis 相关
+      "web.*",                // Web 管理相关（token 管理等）
+      "evol.*",               // Evol 相关（LLM 工具调用等）
+      "kite_console.*",       // Kite Console 业务相关
+      "acp_channel.*",        // ACP Channel 相关
+      "phone_channel.*"       // Phone Channel 相关
+    ],
+
+    // 操作员角色 - 模块管理权限
+    operator: [
+      "event.*",              // 事件订阅（必需）
+      "registry.*",           // 注册表查询
+      "launcher.list_modules",
+      "launcher.start_module",
+      "launcher.stop_module",
+      "launcher.restart_module",
+      "kernel.health",
+      "kernel.stats",
+      "kernel.get_registry_stats", // 注册中心统计数据（新增）
+      "*.health",
+      "*.status",
+      "kite_console.list_kite_tokens",   // Token 查看（只读）
+      "kite_console.list_evol_tokens"    // Token 查看（只读）
+    ],
+
+    // 查看者角色 - 只读权限
+    viewer: [
+      "event.*",              // 事件订阅（必需）
+      "registry.*",           // 注册表查询（只读）
+      "launcher.list_modules",
+      "kernel.health",
+      "kernel.stats",
+      "kernel.get_registry_stats", // 注册中心统计数据（新增）
+      "*.health",
+      "*.status",
+      "kite_console.list_kite_tokens"    // Token 查看（只读）
+    ]
+  }
+}

package/extensions/services/kite_console/routes/__init__.py

@@ -0,0 +1 @@
+

package/extensions/services/kite_console/routes/routes_llm.py

@@ -0,0 +1,231 @@
+"""
+LLM Test Routes
+Provides API endpoints for testing LLM providers (OpenAI, Claude, Gemini).
+"""
+
+import logging
+from typing import List, Dict, Any
+
+from fastapi import APIRouter, HTTPException, Header
+from pydantic import BaseModel
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+
+class ChatMessage(BaseModel):
+    role: str
+    content: str
+
+
+class ChatRequest(BaseModel):
+    provider: str
+    base_url: str
+    api_key: str
+    model: str
+    temperature: float = 0.7
+    max_tokens: int = 1024
+    messages: List[ChatMessage]
+
+
+class ModelInfo(BaseModel):
+    id: str
+    name: str
+
+
+@router.get("/models")
+async def get_models(
+    provider: str,
+    authorization: str = Header(None),
+    x_base_url: str = Header(None, alias="X-Base-URL")
+) -> List[ModelInfo]:
+    """
+    获取指定提供商的可用模型列表（代理到真实 API）
+    """
+    import httpx
+
+    try:
+        # 从 Header 中获取 API Key 和 Base URL
+        api_key = authorization.replace("Bearer ", "") if authorization else None
+        base_url = x_base_url or ""
+
+        if not api_key:
+            raise HTTPException(status_code=400, detail="Missing API Key")
+
+        if not base_url:
+            raise HTTPException(status_code=400, detail="Missing Base URL")
+
+        # 调用真实的 OpenAI 风格 API
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            response = await client.get(
+                f"{base_url}/v1/models",
+                headers={"Authorization": f"Bearer {api_key}"}
+            )
+
+            if response.status_code != 200:
+                raise HTTPException(status_code=response.status_code, detail=response.text)
+
+            data = response.json()
+
+            # 转换为标准格式
+            if "data" in data and isinstance(data["data"], list):
+                models = []
+                for m in data["data"]:
+                    model_id = m.get("id", "")
+                    owned_by = m.get("owned_by", "")
+                    # 组合显示名称：模型ID + 分类
+                    name = f"{model_id} ({owned_by})" if owned_by else model_id
+                    models.append(ModelInfo(id=model_id, name=name))
+                return models
+            else:
+                return []
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Failed to get models for {provider}: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/chat")
+async def chat(request: ChatRequest) -> Dict[str, Any]:
+    """
+    发送聊天消息到指定的 LLM 提供商
+    """
+    try:
+        if request.provider == "openai":
+            return await _chat_openai(request)
+        elif request.provider == "claude":
+            return await _chat_claude(request)
+        elif request.provider == "gemini":
+            return await _chat_gemini(request)
+        else:
+            raise HTTPException(status_code=400, detail=f"Unsupported provider: {request.provider}")
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Chat error with {request.provider}: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+async def _chat_openai(request: ChatRequest) -> Dict[str, Any]:
+    """调用 OpenAI API"""
+    import httpx
+
+    headers = {
+        "Authorization": f"Bearer {request.api_key}",
+        "Content-Type": "application/json",
+    }
+
+    payload = {
+        "model": request.model,
+        "messages": [{"role": msg.role, "content": msg.content} for msg in request.messages],
+        "temperature": request.temperature,
+        "max_tokens": request.max_tokens,
+    }
+
+    async with httpx.AsyncClient(timeout=60.0) as client:
+        response = await client.post(
+            f"{request.base_url}/v1/chat/completions",
+            headers=headers,
+            json=payload,
+        )
+
+        if response.status_code != 200:
+            error_text = response.text
+            raise HTTPException(status_code=response.status_code, detail=error_text)
+
+        result = response.json()
+        content = result.get("choices", [{}])[0].get("message", {}).get("content", "")
+
+        return {"content": content}
+
+
+async def _chat_claude(request: ChatRequest) -> Dict[str, Any]:
+    """调用 Claude API"""
+    import httpx
+
+    headers = {
+        "x-api-key": request.api_key,
+        "anthropic-version": "2023-06-01",
+        "Content-Type": "application/json",
+    }
+
+    # Claude API 需要分离 system 消息
+    messages = []
+    system_message = None
+
+    for msg in request.messages:
+        if msg.role == "system":
+            system_message = msg.content
+        else:
+            messages.append({"role": msg.role, "content": msg.content})
+
+    payload = {
+        "model": request.model,
+        "messages": messages,
+        "temperature": request.temperature,
+        "max_tokens": request.max_tokens,
+    }
+
+    if system_message:
+        payload["system"] = system_message
+
+    async with httpx.AsyncClient(timeout=60.0) as client:
+        response = await client.post(
+            f"{request.base_url}/v1/messages",
+            headers=headers,
+            json=payload,
+        )
+
+        if response.status_code != 200:
+            error_text = response.text
+            raise HTTPException(status_code=response.status_code, detail=error_text)
+
+        result = response.json()
+        content = result.get("content", [{}])[0].get("text", "")
+
+        return {"content": content}
+
+
+async def _chat_gemini(request: ChatRequest) -> Dict[str, Any]:
+    """调用 Gemini API"""
+    import httpx
+
+    # Gemini 使用 URL 参数传递 API Key
+    url = f"{request.base_url}/models/{request.model}:generateContent?key={request.api_key}"
+
+    # 转换消息格式
+    contents = []
+    for msg in request.messages:
+        role = "user" if msg.role == "user" else "model"
+        contents.append({
+            "role": role,
+            "parts": [{"text": msg.content}]
+        })
+
+    payload = {
+        "contents": contents,
+        "generationConfig": {
+            "temperature": request.temperature,
+            "maxOutputTokens": request.max_tokens,
+        }
+    }
+
+    async with httpx.AsyncClient(timeout=60.0) as client:
+        response = await client.post(
+            url,
+            headers={"Content-Type": "application/json"},
+            json=payload,
+        )
+
+        if response.status_code != 200:
+            error_text = response.text
+            raise HTTPException(status_code=response.status_code, detail=error_text)
+
+        result = response.json()
+        content = result.get("candidates", [{}])[0].get("content", {}).get("parts", [{}])[0].get("text", "")
+
+        return {"content": content}

package/extensions/services/kite_console/routes/routes_proxy.py

@@ -0,0 +1,115 @@
+"""
+Proxy routes for logs and audit services.
+Dynamically discovers module ports via Kernel registry.
+"""
+
+import logging
+import time
+from fastapi import APIRouter, Request, HTTPException
+from fastapi.responses import Response, JSONResponse
+import httpx
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(tags=["proxy"])
+
+_evol_server = None
+_http_client = None
+
+# 端口缓存 {module_name: (port, timestamp)}
+_port_cache = {}
+_PORT_CACHE_TTL = 30  # 30秒缓存
+
+
+def set_proxy_server(server):
+    """Set the EvolServer instance for registry lookup."""
+    global _evol_server
+    _evol_server = server
+
+
+def _get_http_client():
+    global _http_client
+    if _http_client is None:
+        _http_client = httpx.AsyncClient(timeout=15.0)
+    return _http_client
+
+
+async def _resolve_port(module_name: str) -> int:
+    """通过注册中心动态发现模块端口"""
+    now = time.time()
+    cached = _port_cache.get(module_name)
+    if cached and (now - cached[1]) < _PORT_CACHE_TTL:
+        return cached[0]
+
+    if not _evol_server:
+        raise HTTPException(status_code=503, detail=f"Proxy server not initialized")
+
+    if not _evol_server._ws:
+        raise HTTPException(status_code=503, detail=f"Kernel WebSocket not connected")
+
+    # 通过注册中心查询端口
+    try:
+        resp = await _evol_server._rpc_call(_evol_server._ws, 'registry.lookup', {
+            'module': module_name,
+            'field': 'http_port'
+        })
+        # _rpc_call 返回完整 JSON-RPC 响应，需要解包 result 层
+        inner = resp.get('result', resp)
+        records = inner.get('results', [])
+        if records:
+            port = int(records[0].get('value', 0))
+            if port > 0:
+                _port_cache[module_name] = (port, now)
+                return port
+        logger.warning(f"[proxy] {module_name} http_port not found in registry, results={records}")
+    except Exception as e:
+        logger.warning(f"[proxy] Registry lookup failed for {module_name}: {e}")
+
+    raise HTTPException(
+        status_code=503,
+        detail=f"{module_name} module is not running or not registered"
+    )
+
+
+async def _proxy_request(module_name: str, api_prefix: str, path: str, request: Request):
+    """通用代理转发"""
+    port = await _resolve_port(module_name)
+    client = _get_http_client()
+    url = f"http://127.0.0.1:{port}/{api_prefix}/{path}"
+
+    if request.url.query:
+        url += f"?{request.url.query}"
+
+    try:
+        resp = await client.request(
+            method=request.method,
+            url=url,
+            content=await request.body() if request.method in ("POST", "PUT", "DELETE") else None,
+        )
+        safe_headers = {k: v for k, v in resp.headers.items()
+                        if k.lower() not in ('transfer-encoding', 'connection', 'content-encoding', 'content-length')}
+        return Response(
+            content=resp.content,
+            status_code=resp.status_code,
+            headers=safe_headers,
+            media_type=resp.headers.get('content-type'),
+        )
+    except httpx.ConnectError:
+        _port_cache.pop(module_name, None)
+        raise HTTPException(status_code=503, detail=f"{module_name} service unavailable (connect failed to port {port})")
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.api_route("/proxy/logs/{path:path}", methods=["GET", "POST", "DELETE"])
+async def proxy_logs(path: str, request: Request):
+    """代理日志服务请求"""
+    return await _proxy_request('logs', 'api/logs', path, request)
+
+
+@router.api_route("/proxy/audit/{path:path}", methods=["GET", "POST"])
+async def proxy_audit(path: str, request: Request):
+    """代理审计服务请求"""
+    return await _proxy_request('audit', 'api/audit', path, request)

package/extensions/services/kite_console/routes/routes_rpc.py

@@ -0,0 +1,89 @@
+"""RPC forwarding routes — forward HTTP requests to Kernel RPC."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import uuid
+
+from fastapi import APIRouter, HTTPException, Request
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(tags=["rpc"])
+
+# Global reference to EvolServer instance (set by server.py)
+_evol_server = None
+
+
+def set_evol_server(server):
+    """Set the EvolServer instance for RPC forwarding."""
+    global _evol_server
+    _evol_server = server
+
+
+@router.post("/rpc/{method:path}")
+async def forward_rpc(method: str, request: Request):
+    """
+    Forward RPC call to Kernel via WebSocket.
+
+    Example:
+        POST /api/rpc/launcher.start_module
+        Body: {"name": "watchdog"}
+    """
+    if not _evol_server:
+        raise HTTPException(503, "Evol 模块未初始化")
+
+    if not _evol_server._ws:
+        raise HTTPException(503, "Evol 模块未连接到 Kernel，请检查 Kernel 是否正常运行")
+
+    try:
+        body = await request.json()
+    except Exception:
+        body = {}
+
+    # Generate unique request ID
+    rpc_id = str(uuid.uuid4())
+
+    # Create RPC request
+    rpc_request = {
+        "jsonrpc": "2.0",
+        "id": rpc_id,
+        "method": method,
+        "params": body,
+    }
+
+    # Create a future to wait for response
+    response_future = asyncio.Future()
+
+    # Store the future in a dict (keyed by rpc_id)
+    if not hasattr(_evol_server, '_pending_rpc'):
+        _evol_server._pending_rpc = {}
+    _evol_server._pending_rpc[rpc_id] = response_future
+
+    # Send RPC request
+    try:
+        await _evol_server._ws.send(json.dumps(rpc_request))
+    except Exception as e:
+        _evol_server._pending_rpc.pop(rpc_id, None)
+        raise HTTPException(503, f"发送 RPC 请求失败: {str(e)}")
+
+    # Wait for response (with timeout)
+    try:
+        response = await asyncio.wait_for(response_future, timeout=30.0)
+    except asyncio.TimeoutError:
+        _evol_server._pending_rpc.pop(rpc_id, None)
+        raise HTTPException(504, f"RPC 请求超时（30秒），目标服务可能未响应")
+    finally:
+        _evol_server._pending_rpc.pop(rpc_id, None)
+
+    # Check for RPC error
+    if "error" in response:
+        error = response["error"]
+        error_msg = error.get('message', '未知错误')
+        error_code = error.get('code', -1)
+        raise HTTPException(500, f"RPC 调用失败: {error_msg} (code: {error_code})")
+
+    # Return result
+    return response.get("result", {})

package/extensions/services/kite_console/routes/routes_test.py

@@ -0,0 +1,68 @@
+"""
+测试日志 API 路由
+"""
+import os
+from datetime import datetime
+from pathlib import Path
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+router = APIRouter()
+
+
+class TestLogRequest(BaseModel):
+    """测试日志请求"""
+    content: str
+    test_name: str = "registry_test"
+
+
+@router.post("/save_test_log")
+async def save_test_log(req: TestLogRequest):
+    """
+    保存测试日志到服务器
+
+    日志保存路径: {KITE_MODULE_DATA}/log/{test_name}.log (每次覆盖)
+
+    支持的测试类型:
+    - registry_test: 注册中心测试（旧版，兼容）
+    - module_test: 模块测试
+    - integration_test: 集成测试
+    - full_test: 完整测试
+    """
+    try:
+        # 获取模块数据目录
+        module_data = os.environ.get("KITE_MODULE_DATA")
+        if not module_data:
+            raise HTTPException(status_code=500, detail="KITE_MODULE_DATA not set")
+
+        # 日志保存到 log 目录（与 latest.log 同级）
+        log_dir = Path(module_data) / "log"
+        log_dir.mkdir(parents=True, exist_ok=True)
+
+        # 根据测试类型确定文件名
+        log_file = log_dir / f"{req.test_name}.log"
+
+        # 写入日志（覆盖模式）
+        now = datetime.now()
+        with open(log_file, "w", encoding="utf-8") as f:
+            f.write(f"# Kite 测试日志 - {req.test_name}\n")
+            f.write(f"# 测试时间: {now.isoformat()}\n")
+            f.write(f"# {'=' * 70}\n\n")
+            f.write(req.content)
+
+        # 输出到控制台（会被 Launcher 捕获）
+        print(f"\n{'=' * 70}")
+        print(f"[evol] 测试日志已保存")
+        print(f"[evol] 类型: {req.test_name}")
+        print(f"[evol] 路径: {log_file}")
+        print(f"[evol] 时间: {now.strftime('%Y-%m-%d %H:%M:%S')}")
+        print(f"{'=' * 70}\n")
+
+        return {
+            "success": True,
+            "log_path": str(log_file),
+            "timestamp": now.isoformat()
+        }
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Failed to save log: {str(e)}")