Hermes api_server 平台适配方案

def _check_auth(self, request: web.Request) -> Optional[web.Response]:
    if not self._api_key:
        return None  # 未配置 API Key → 允许所有（仅本地使用）

    auth_header = request.headers.get("Authorization", "")
    # 标准 Bearer Token 格式

_CORS_HEADERS = {
    "Access-Control-Allow-Methods": "GET, POST, DELETE, OPTIONS",
    "Access-Control-Allow-Headers": "Authorization, Content-Type, Idempotency-Key",
}

class TypingBroadcast:
    def __init__(self):
        # chat_id -> list of WebSocket connections
        self._subscribers: Dict[str, List[WebSocket]] = {}

    async def broadcast(self, chat_id: str, status: str):
        for ws in self._subscribers.get(chat_id, []):
            await ws.send_json({"type": "typing", "chat_id": chat_id, "status": status})

import secrets

def generate_token() -> str:
    """生成64位安全的随机Token"""
    return secrets.token_bytes(32).hex()  # 64字符

async def auth_middleware(request, call_next):
    token = request.headers.get("Authorization", "").replace("Bearer ", "")
    if not token:
        return Response(401, body="Missing token")

    row = await db.query("""
        SELECT u.id, u.tenant_id, u.is_active, t.is_active
        FROM auth_tokens r
        JOIN users u ON r.user_id = u.id
        JOIN tenants t ON r.tenant_id = t.id
        WHERE r.token = ? AND r.is_revoked = 0
        AND u.is_active = 1 AND t.is_active = 1
        AND (r.expires_at IS NULL OR r.expires_at > NOW())
    """, token)

    if not row:
        return Response(401, body="Invalid token")

    # 注入到请求上下文，应用层无法伪造
    request.user_id   = row["id"]
    request.tenant_id = row["tenant_id"]
    return await call_next(request)

async def log_message(
    session_id: str,
    tenant_id: int,
    user_id: int,
    role: str,                    # user | assistant | tool
    content: Any,
    content_type: str = "text",
    metadata: Optional[dict] = None,
):
    """统一消息记录入口"""
    message_id = f"msg_{secrets.token_hex(16)}"

    await db.execute("""
        INSERT INTO chat_messages
        (message_id, session_id, tenant_id, user_id, role,
         content, content_type, model, provider, is_custom_key,
         custom_key_id, input_tokens, output_tokens, latency_ms,
         status, error_code, error_msg, client_version, ip_address,
         device_info, reply_to_id)
        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
    """,
        message_id, session_id, tenant_id, user_id, role,
        serialize_content(content), content_type,
        metadata.get("model"),
        metadata.get("provider"),
        metadata.get("is_custom_key", 0),
        metadata.get("custom_key_id"),
        metadata.get("input_tokens", 0),
        metadata.get("output_tokens", 0),
        metadata.get("latency_ms", 0),
        metadata.get("status", "success"),
        metadata.get("error_code"),
        metadata.get("error_msg"),
        metadata.get("client_version"),
        metadata.get("ip_address"),
        metadata.get("device_info"),
        metadata.get("reply_to_id"),
    )

    # 更新会话计数
    await db.execute("""
        UPDATE chat_sessions
        SET message_count = message_count + 1,
            updated_at = NOW()
        WHERE session_id = ?
    """, session_id)

    return message_id


async def log_tool_call(
    message_id: str,
    session_id: str,
    tenant_id: int,
    tool_name: str,
    tool_call_id: str,
    tool_input: dict,
    tool_output: Any,
    latency_ms: int,
    status: str = "success",
    error_msg: str = None,
):
    await db.execute("""
        INSERT INTO tool_call_logs
        (message_id, session_id, tenant_id, tool_name, tool_call_id,
         tool_input, tool_output, status, error_msg, latency_ms)
        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
    """,
        message_id, session_id, tenant_id, tool_name, tool_call_id,
        json.dumps(tool_input),
        json.dumps(tool_output) if isinstance(tool_output, dict) else str(tool_output),
        status, error_msg, latency_ms
    )

# 获取用户会话列表
GET /api/sessions?tenant_id=x&user_id=y&limit=20&offset=0

# 获取会话详情（含消息历史）
GET /api/sessions/{session_id}/messages?limit=50&offset=0

# 搜索会话内容
GET /api/sessions/search?q=关键词&tenant_id=x&user_id=y

# 获取统计数据
GET /api/analytics/overview?tenant_id=x&start=2026-05-01&end=2026-05-04
# 返回：总消息数 / 总会话数 / 平均响应耗时 / top工具调用 / top问题

# App 端允许的命令（白名单）
ALLOWED_COMMANDS = {
    "/reset": "重置当前会话上下文，保留会话历史仅清除 Agent 记忆",
    "/new": "开启一个新的会话，保留当前会话记录",
}

# App 端屏蔽的命令（黑名单）
BLOCKED_COMMANDS = {
    # 会话类（危险）
    "/reset_all": "危险：清除所有会话",
    "/clear": "危险：清空上下文",

    # 系统类（危险）
    "/exec": "危险：执行系统命令",
    "/bash": "危险：执行 shell 命令",
    "/sudo": "危险：提权操作",

    # 模型类（干扰体验）
    "/model": "在 App 内无需切换模型",
    "/provider": "在 App 内无需切换 Provider",

    # 工具类（干扰体验）
    "/tools": "App 内无需查看工具列表",
    "/tool": "App 内无需手动调用工具",

    # 配置类（干扰体验）
    "/set": "App 内不支持自定义配置",
    "/config": "App 内不支持修改配置",

    # Agent 引导类（干扰体验）
    "/steer": "App 内不支持引导 Agent 行为",
    "/persona": "App 内无需切换人格",

    # 调试类（生产环境禁用）
    "/debug": "生产环境禁用调试",
    "/verbose": "生产环境禁用详细日志",
    "/trace": "生产环境禁用跟踪",

    # 信息类（无意义）
    "/help": "App 内无需命令行帮助",
    "/usage": "App 内无需查看用量",
    "/stats": "App 内无需查看统计",
}

# 在 api_server 的 chat completions 处理前拦截
ALLOWED_COMMANDS = {"/reset", "/new"}
BLOCKED_COMMANDS = {
    "/exec", "/bash", "/sudo", "/reset_all", "/clear",
    "/model", "/provider", "/tools", "/tool",
    "/set", "/config", "/steer", "/persona",
    "/debug", "/verbose", "/trace",
    "/help", "/usage", "/stats",
}

@app.middleware
async def block_commands(request, call_next):
    if request.path != "/v1/chat/completions":
        return await call_next(request)

    body = await request.json()
    last_message = body.get("messages", [])[-1]
    content = last_message.get("content", "")

    if isinstance(content, str) and content.startswith("/"):
        cmd = content.strip().split()[0].lower()
        if cmd in BLOCKED_COMMANDS:
            return web.json_response({
                "error": {
                    "code": "command_blocked",
                    "message": f"命令 /{cmd.lstrip('/')} 在 App 内已被屏蔽，仅支持 /reset 和 /new"
                }
            }, status=400)

    return await call_next(request)

async def handle_reset(session_id: str, tenant_id: int, user_id: int) -> dict:
    """
    /reset 实现：
    1. 清除 AIAgent 的当前 context window
    2. 在 chat_sessions 中记录 reset 事件
    3. 发送系统消息："已重置，可以重新开始"
    """
    # 通知 Hermes 清除会话记忆
    await hermes.clear_session_context(session_id)

    # 写入系统消息
    await log_message(
        session_id=session_id,
        tenant_id=tenant_id,
        user_id=user_id,
        role="system",
        content="会话已重置，之前的上下文已清除。有什么可以帮你的？",
        content_type="text",
    )

    return {"status": "reset", "session_id": session_id}


async def handle_new(tenant_id: int, user_id: int) -> dict:
    """
    /new 实现：
    1. 关闭旧会话（status=closed）
    2. 创建新 session_id
    3. 初始化新会话记录
    4. 返回新 session_id 给 App 切换
    """
    old_session_id = get_current_session_id(user_id)

    # 关闭旧会话
    if old_session_id:
        await db.execute("""
            UPDATE chat_sessions
            SET status='closed', closed_at=NOW()
            WHERE session_id=?
        """, old_session_id)

    # 创建新会话
    new_session_id = f"sess_{secrets.token_hex(16)}"
    await db.execute("""
        INSERT INTO chat_sessions (session_id, tenant_id, user_id, title, status)
        VALUES (?, ?, ?, '新会话', 'active')
    """, new_session_id, tenant_id, user_id)

    return {"status": "new_session", "session_id": new_session_id}