@agentunion/kite 1.5.0 → 1.6.0

package/extensions/services/dataclaw/api/reviews.py

@@ -0,0 +1,138 @@
+"""
+评价与举报 API
+"""
+from fastapi import APIRouter, Depends, HTTPException, Query
+from pydantic import BaseModel
+from sqlalchemy import text
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from core.auth import require_auth
+from core.database import get_session
+
+router = APIRouter()
+DISC = {"entry": "/.well-known/agent-data-exchange.json"}
+
+
+class CreateReviewRequest(BaseModel):
+    rating: int
+    comment: str = ""
+
+
+class ReportRequest(BaseModel):
+    reason: str  # fake_data / harmful_content / illegal_source / long_inactive
+    description: str = ""
+
+
+@router.get("/{feed_id}/reviews")
+async def list_reviews(
+    feed_id: str,
+    limit: int = Query(20, ge=1, le=100),
+    offset: int = Query(0, ge=0),
+    session: AsyncSession = Depends(get_session)
+):
+    rows = (await session.execute(
+        text("""
+            SELECT r.id, r.rating, r.comment, r.created_at, a.name AS agent_name
+            FROM reviews r
+            LEFT JOIN agents a ON a.id = r.agent_id
+            WHERE r.feed_id = :fid
+            ORDER BY r.created_at DESC
+            LIMIT :lim OFFSET :off
+        """),
+        {"fid": feed_id, "lim": limit, "off": offset}
+    )).fetchall()
+    total = (await session.execute(
+        text("SELECT COUNT(*) FROM reviews WHERE feed_id=:fid"), {"fid": feed_id}
+    )).scalar()
+    avg = (await session.execute(
+        text("SELECT AVG(rating) FROM reviews WHERE feed_id=:fid"), {"fid": feed_id}
+    )).scalar()
+    reviews = [
+        {"id": r.id, "rating": r.rating, "comment": r.comment,
+         "agent_name": r.agent_name,
+         "created_at": r.created_at.isoformat() if r.created_at else None}
+        for r in rows
+    ]
+    return {"ok": True, "data": {
+        "reviews": reviews, "total": total,
+        "avg_rating": round(float(avg), 2) if avg else None,
+        "limit": limit, "offset": offset
+    }, "_discovery": DISC}
+
+
+@router.post("/{feed_id}/reviews")
+async def create_review(
+    feed_id: str,
+    body: CreateReviewRequest,
+    agent_id: str = Depends(require_auth),
+    session: AsyncSession = Depends(get_session)
+):
+    if not 1 <= body.rating <= 5:
+        raise HTTPException(400, detail={"ok": False, "error": "INVALID_RATING",
+                                          "message": "评分必须在 1-5 之间", "_discovery": DISC})
+    feed = (await session.execute(
+        text("SELECT id FROM feeds WHERE id=:fid AND status!='deleted'"), {"fid": feed_id}
+    )).fetchone()
+    if not feed:
+        raise HTTPException(404, detail={"ok": False, "error": "FEED_NOT_FOUND", "_discovery": DISC})
+    existing = (await session.execute(
+        text("SELECT id FROM reviews WHERE feed_id=:fid AND agent_id=:aid"),
+        {"fid": feed_id, "aid": agent_id}
+    )).fetchone()
+    if existing:
+        await session.execute(
+            text("UPDATE reviews SET rating=:r, comment=:c WHERE feed_id=:fid AND agent_id=:aid"),
+            {"r": body.rating, "c": body.comment, "fid": feed_id, "aid": agent_id}
+        )
+    else:
+        await session.execute(
+            text("INSERT INTO reviews (feed_id, agent_id, rating, comment) VALUES (:fid, :aid, :r, :c)"),
+            {"fid": feed_id, "aid": agent_id, "r": body.rating, "c": body.comment}
+        )
+    # 更新信誉分
+    await _update_reputation(feed_id, session)
+    await session.commit()
+    return {"ok": True, "data": {"feed_id": feed_id, "rating": body.rating,
+                                  "message": "评价已提交"}, "_discovery": DISC}
+
+
+@router.post("/{feed_id}/report")
+async def report_feed(
+    feed_id: str,
+    body: ReportRequest,
+    agent_id: str = Depends(require_auth),
+    session: AsyncSession = Depends(get_session)
+):
+    valid_reasons = {"fake_data", "harmful_content", "illegal_source", "long_inactive"}
+    if body.reason not in valid_reasons:
+        raise HTTPException(400, detail={"ok": False, "error": "INVALID_REASON",
+                                          "message": f"无效的举报原因，可选：{valid_reasons}",
+                                          "_discovery": DISC})
+    feed = (await session.execute(
+        text("SELECT id FROM feeds WHERE id=:fid"), {"fid": feed_id}
+    )).fetchone()
+    if not feed:
+        raise HTTPException(404, detail={"ok": False, "error": "FEED_NOT_FOUND", "_discovery": DISC})
+    await session.execute(
+        text("""
+            INSERT INTO reports (feed_id, reporter_id, reason, description, status)
+            VALUES (:fid, :rid, :reason, :desc, 'pending')
+        """),
+        {"fid": feed_id, "rid": agent_id, "reason": body.reason, "desc": body.description}
+    )
+    await session.commit()
+    return {"ok": True, "data": {"feed_id": feed_id, "reason": body.reason,
+                                  "message": "举报已提交，平台将在 24h 内处理"}, "_discovery": DISC}
+
+
+async def _update_reputation(feed_id: str, session: AsyncSession):
+    """重新计算接口信誉分"""
+    avg_rating = (await session.execute(
+        text("SELECT AVG(rating) FROM reviews WHERE feed_id=:fid"), {"fid": feed_id}
+    )).scalar() or 3.0
+    # 简单公式：(avg_rating / 5) * 100，范围 0-100
+    score = min(100, max(0, (float(avg_rating) / 5.0) * 100))
+    await session.execute(
+        text("UPDATE feeds SET reputation_score=:score WHERE id=:fid"),
+        {"score": round(score, 2), "fid": feed_id}
+    )

package/extensions/services/dataclaw/api/search.py

@@ -0,0 +1,153 @@
+"""
+搜索与发现 API
+"""
+from typing import Optional
+
+from fastapi import APIRouter, Depends, Query
+from sqlalchemy import text
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from core.auth import get_current_agent
+from core.database import get_session
+
+router = APIRouter()
+DISC = {"entry": "/.well-known/agent-data-exchange.json"}
+
+
+@router.get("/search/feeds")
+async def search_feeds(
+    q: Optional[str] = Query(None, description="搜索关键词"),
+    category: Optional[str] = Query(None),
+    tags: Optional[str] = Query(None, description="逗号分隔的标签"),
+    sort: str = Query("reputation", description="排序：reputation/subscribers/created"),
+    limit: int = Query(20, ge=1, le=100),
+    offset: int = Query(0, ge=0),
+    session: AsyncSession = Depends(get_session)
+):
+    conditions = ["f.status='active'"]
+    params = {"lim": limit, "off": offset}
+
+    if q:
+        conditions.append("(f.name LIKE :q OR f.description LIKE :q)")
+        params["q"] = f"%{q}%"
+    if category:
+        conditions.append("JSON_CONTAINS(f.category, :cat)")
+        params["cat"] = f'"{category}"'
+
+    where = " AND ".join(conditions)
+    order_map = {
+        "reputation": "f.reputation_score DESC",
+        "subscribers": "f.subscriber_count DESC",
+        "created": "f.created_at DESC"
+    }
+    order = order_map.get(sort, "f.reputation_score DESC")
+
+    sql = f"""
+        SELECT f.id, f.name, f.description, f.update_cycle, f.category, f.tags,
+               f.reputation_score, f.subscriber_count, f.last_data_at,
+               a.name AS owner_name
+        FROM feeds f
+        LEFT JOIN agents a ON a.id = f.owner_id
+        WHERE {where}
+        ORDER BY {order}
+        LIMIT :lim OFFSET :off
+    """
+    rows = (await session.execute(text(sql), params)).fetchall()
+    count_sql = f"SELECT COUNT(*) FROM feeds f WHERE {where}"
+    total = (await session.execute(text(count_sql), {k: v for k, v in params.items() if k not in ('lim', 'off')})).scalar()
+
+    feeds = []
+    for r in rows:
+        feeds.append({
+            "id": r.id, "name": r.name, "description": r.description,
+            "update_cycle": r.update_cycle, "category": r.category, "tags": r.tags,
+            "reputation_score": float(r.reputation_score),
+            "subscriber_count": r.subscriber_count,
+            "last_data_at": r.last_data_at.isoformat() if r.last_data_at else None,
+            "owner_name": r.owner_name
+        })
+    return {"ok": True, "data": {"feeds": feeds, "total": total,
+                                  "limit": limit, "offset": offset,
+                                  "query": q}, "_discovery": DISC}
+
+
+@router.get("/trending")
+async def get_trending(
+    period: str = Query("week", description="day/week/month"),
+    limit: int = Query(20, ge=1, le=100),
+    session: AsyncSession = Depends(get_session)
+):
+    interval_map = {"day": "1 DAY", "week": "7 DAY", "month": "30 DAY"}
+    interval = interval_map.get(period, "7 DAY")
+    rows = (await session.execute(
+        text(f"""
+            SELECT f.id, f.name, f.description, f.update_cycle, f.category,
+                   f.reputation_score, f.subscriber_count, f.last_data_at
+            FROM feeds f
+            WHERE f.status='active' AND f.last_data_at >= DATE_SUB(NOW(), INTERVAL {interval})
+            ORDER BY f.subscriber_count DESC, f.total_queries DESC
+            LIMIT :lim
+        """),
+        {"lim": limit}
+    )).fetchall()
+    feeds = []
+    for r in rows:
+        feeds.append({
+            "id": r.id, "name": r.name, "description": r.description,
+            "update_cycle": r.update_cycle, "category": r.category,
+            "reputation_score": float(r.reputation_score),
+            "subscriber_count": r.subscriber_count,
+            "last_data_at": r.last_data_at.isoformat() if r.last_data_at else None
+        })
+    return {"ok": True, "data": {"feeds": feeds, "period": period, "total": len(feeds)}, "_discovery": DISC}
+
+
+@router.get("/categories")
+async def get_categories(session: AsyncSession = Depends(get_session)):
+    """返回预定义分类目录"""
+    categories = [
+        {"id": "finance", "name": "金融财经", "sub": ["crypto", "stock", "forex", "commodity"]},
+        {"id": "tech", "name": "科技资讯", "sub": ["github", "ai", "product", "security"]},
+        {"id": "news", "name": "新闻资讯", "sub": ["global", "china", "tech_news", "business"]},
+        {"id": "data", "name": "数据统计", "sub": ["social", "search", "traffic", "sentiment"]},
+        {"id": "weather", "name": "天气环境", "sub": ["forecast", "air_quality", "disaster"]},
+        {"id": "ecommerce", "name": "电商零售", "sub": ["price", "ranking", "review", "trend"]},
+        {"id": "social", "name": "社交媒体", "sub": ["twitter", "weibo", "reddit", "hackernews"]},
+        {"id": "research", "name": "学术研究", "sub": ["arxiv", "paper", "patent", "report"]},
+    ]
+    return {"ok": True, "data": {"categories": categories}, "_discovery": DISC}
+
+
+@router.get("/recommendations")
+async def get_recommendations(
+    limit: int = Query(10, ge=1, le=50),
+    agent_id: Optional[str] = Depends(get_current_agent),
+    session: AsyncSession = Depends(get_session)
+):
+    """个性化推荐（基于订阅历史的分类推荐）"""
+    if not agent_id:
+        # 未登录用户返回热门
+        rows = (await session.execute(
+            text("SELECT id, name, description, reputation_score, subscriber_count "
+                 "FROM feeds WHERE status='active' ORDER BY subscriber_count DESC LIMIT :lim"),
+            {"lim": limit}
+        )).fetchall()
+    else:
+        # 已登录：找订阅过的分类，推荐同类其他 feed
+        rows = (await session.execute(
+            text("""
+                SELECT f.id, f.name, f.description, f.reputation_score, f.subscriber_count
+                FROM feeds f
+                WHERE f.status='active'
+                  AND f.id NOT IN (SELECT feed_id FROM subscriptions WHERE agent_id=:aid)
+                ORDER BY f.reputation_score DESC, f.subscriber_count DESC
+                LIMIT :lim
+            """),
+            {"aid": agent_id, "lim": limit}
+        )).fetchall()
+    feeds = [
+        {"id": r.id, "name": r.name, "description": r.description,
+         "reputation_score": float(r.reputation_score), "subscriber_count": r.subscriber_count}
+        for r in rows
+    ]
+    return {"ok": True, "data": {"recommendations": feeds}, "_discovery": DISC}

package/extensions/services/dataclaw/api/subscriptions.py

@@ -0,0 +1,157 @@
+"""
+订阅与时间线 API
+"""
+from typing import Optional, List
+
+from fastapi import APIRouter, Depends, HTTPException, Query
+from pydantic import BaseModel
+from sqlalchemy import text
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from core.auth import require_auth
+from core.database import get_session
+from utils.id_generator import gen_sub_id
+
+router = APIRouter()
+DISC = {"entry": "/.well-known/agent-data-exchange.json"}
+
+
+class SubscribeRequest(BaseModel):
+    feed_ids: List[str]
+    auto_unsubscribe: dict = {}
+
+
+class UnsubscribeRequest(BaseModel):
+    feed_ids: List[str]
+
+
+@router.get("/subscriptions")
+async def list_subscriptions(
+    agent_id: str = Depends(require_auth),
+    session: AsyncSession = Depends(get_session)
+):
+    rows = (await session.execute(
+        text("""
+            SELECT s.id, s.feed_id, f.name, f.update_cycle, f.status AS feed_status,
+                   f.last_data_at, s.subscribed_at
+            FROM subscriptions s
+            JOIN feeds f ON f.id = s.feed_id
+            WHERE s.agent_id = :aid
+            ORDER BY s.subscribed_at DESC
+        """),
+        {"aid": agent_id}
+    )).fetchall()
+    subs = []
+    for r in rows:
+        subs.append({
+            "sub_id": r.id, "feed_id": r.feed_id, "feed_name": r.name,
+            "update_cycle": r.update_cycle, "feed_status": r.feed_status,
+            "last_data_at": r.last_data_at.isoformat() if r.last_data_at else None,
+            "subscribed_at": r.subscribed_at.isoformat() if r.subscribed_at else None
+        })
+    return {"ok": True, "data": {"subscriptions": subs, "total": len(subs)}, "_discovery": DISC}
+
+
+@router.post("/subscriptions")
+async def subscribe(
+    body: SubscribeRequest,
+    agent_id: str = Depends(require_auth),
+    session: AsyncSession = Depends(get_session)
+):
+    import json
+    results = []
+    for feed_id in body.feed_ids:
+        # 检查 feed 是否存在
+        feed = (await session.execute(
+            text("SELECT id, name, status FROM feeds WHERE id=:id AND status!='deleted'"),
+            {"id": feed_id}
+        )).fetchone()
+        if not feed:
+            results.append({"feed_id": feed_id, "ok": False, "error": "FEED_NOT_FOUND"})
+            continue
+        # ��查是否已订阅
+        existing = (await session.execute(
+            text("SELECT id FROM subscriptions WHERE agent_id=:aid AND feed_id=:fid"),
+            {"aid": agent_id, "fid": feed_id}
+        )).fetchone()
+        if existing:
+            results.append({"feed_id": feed_id, "ok": False, "error": "ALREADY_SUBSCRIBED"})
+            continue
+        sub_id = gen_sub_id()
+        await session.execute(
+            text("""
+                INSERT INTO subscriptions (id, agent_id, feed_id, auto_unsubscribe)
+                VALUES (:sid, :aid, :fid, :auto)
+            """),
+            {"sid": sub_id, "aid": agent_id, "fid": feed_id,
+             "auto": json.dumps(body.auto_unsubscribe)}
+        )
+        await session.execute(
+            text("UPDATE feeds SET subscriber_count=subscriber_count+1 WHERE id=:fid"),
+            {"fid": feed_id}
+        )
+        results.append({"feed_id": feed_id, "ok": True, "sub_id": sub_id, "feed_name": feed.name})
+    await session.commit()
+    return {"ok": True, "data": {"results": results}, "_discovery": DISC}
+
+
+@router.delete("/subscriptions")
+async def unsubscribe(
+    body: UnsubscribeRequest,
+    agent_id: str = Depends(require_auth),
+    session: AsyncSession = Depends(get_session)
+):
+    results = []
+    for feed_id in body.feed_ids:
+        result = await session.execute(
+            text("DELETE FROM subscriptions WHERE agent_id=:aid AND feed_id=:fid"),
+            {"aid": agent_id, "fid": feed_id}
+        )
+        if result.rowcount > 0:
+            await session.execute(
+                text("UPDATE feeds SET subscriber_count=GREATEST(0, subscriber_count-1) WHERE id=:fid"),
+                {"fid": feed_id}
+            )
+            results.append({"feed_id": feed_id, "ok": True})
+        else:
+            results.append({"feed_id": feed_id, "ok": False, "error": "NOT_SUBSCRIBED"})
+    await session.commit()
+    return {"ok": True, "data": {"results": results}, "_discovery": DISC}
+
+
+@router.get("/timeline")
+async def get_timeline(
+    since: Optional[str] = Query(None, description="ISO8601 timestamp"),
+    category: Optional[str] = Query(None),
+    limit: int = Query(20, ge=1, le=100),
+    agent_id: str = Depends(require_auth),
+    session: AsyncSession = Depends(get_session)
+):
+    """获取订阅接口的时间线（聚合所有订阅的最新数据更新）"""
+    base_sql = """
+        SELECT fv.feed_id, f.name AS feed_name, fv.version_num, fv.summary,
+               fv.size_bytes, fv.created_at
+        FROM feed_versions fv
+        JOIN feeds f ON f.id = fv.feed_id
+        JOIN subscriptions s ON s.feed_id = fv.feed_id AND s.agent_id = :aid
+        WHERE 1=1
+    """
+    params = {"aid": agent_id, "lim": limit}
+    if since:
+        base_sql += " AND fv.created_at > :since"
+        params["since"] = since
+    if category:
+        base_sql += " AND JSON_CONTAINS(f.category, :cat)"
+        params["cat"] = f'"{category}"'
+    base_sql += " ORDER BY fv.created_at DESC LIMIT :lim"
+    rows = (await session.execute(text(base_sql), params)).fetchall()
+    items = []
+    for r in rows:
+        items.append({
+            "feed_id": r.feed_id, "feed_name": r.feed_name,
+            "version": r.version_num, "summary": r.summary,
+            "size_bytes": r.size_bytes,
+            "timestamp": r.created_at.isoformat() if r.created_at else None,
+            "data_url": f"/v1/feeds/{r.feed_id}/data/versions/{r.version_num}"
+        })
+    return {"ok": True, "data": {"items": items, "total": len(items)}, "_discovery": DISC}

package/extensions/services/dataclaw/config.json5

@@ -0,0 +1,96 @@
+// DataClaw 业务配置
+{
+  // MySQL 数据库
+  database: {
+    host: "139.196.30.171",
+    port: 3308,
+    user: "root",
+    password: "LWJly100973@",
+    database: "dataclaw",
+    pool_size: 20,
+    max_overflow: 10,
+    pool_recycle: 3600,
+    pool_pre_ping: true
+  },
+
+  // HTTP 服务
+  server: {
+    host: "0.0.0.0",
+    port: 20010
+  },
+
+  // JWT 认证
+  jwt: {
+    secret_key: "dataclaw-jwt-secret-change-in-production",
+    algorithm: "HS256",
+    access_token_expire_hours: 24
+  },
+
+  // 短信服务（阿里云）
+  sms: {
+    enabled: false,
+    access_key_id: "",
+    access_key_secret: "",
+    sign_name: "DataClaw",
+    template_register: "SMS_000000001",
+    template_recover: "SMS_000000002"
+  },
+
+  // 邮件服务
+  email: {
+    enabled: false,
+    smtp_host: "smtp.example.com",
+    smtp_port: 587,
+    smtp_user: "",
+    smtp_password: "",
+    from_address: "noreply@dataclaw.io",
+    from_name: "DataClaw"
+  },
+
+  // OAuth 第三方登录
+  oauth: {
+    github: {
+      enabled: false,
+      client_id: "",
+      client_secret: "",
+      redirect_uri: "http://localhost:20010/auth/github/callback"
+    },
+    google: {
+      enabled: false,
+      client_id: "",
+      client_secret: "",
+      redirect_uri: "http://localhost:20010/auth/google/callback"
+    }
+  },
+
+  // 支付
+  payment: {
+    alipay: { enabled: false, app_id: "", private_key: "", alipay_public_key: "" },
+    wechat: { enabled: false, app_id: "", mch_id: "", api_key: "" },
+    stripe: { enabled: false, api_key: "", webhook_secret: "" },
+    paypal: { enabled: false, client_id: "", client_secret: "", sandbox: true }
+  },
+
+  // 积分
+  credits: {
+    initial_credits: 100.0,
+    verified_bonus: 50.0,
+    exchange_rate: 100,    // ¥1 = 100 积分
+    platform_commission: 0.15  // 15% 平台抽成
+  },
+
+  // 限流
+  rate_limit: {
+    anonymous_per_minute: 10,
+    authenticated_per_minute: 600,
+    premium_per_minute: 6000
+  },
+
+  // 数据保留
+  data_retention: {
+    recent_days: 7,          // 7 天内全保留
+    monthly_days: 30,        // 7-30 天保留每日最后一个
+    quarterly_days: 90,      // 30-90 天保留每周最后一个
+    archived_keep_days: 90   // 接口归档后保留 90 天
+  }
+}

package/extensions/services/dataclaw/core/auth.py

@@ -0,0 +1,95 @@
+"""
+JWT 认证中间件和 FastAPI 依赖
+"""
+from datetime import datetime, timedelta, timezone
+from typing import Optional
+
+import jwt
+from fastapi import Depends, HTTPException, Request, status
+from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import text
+
+from core.database import get_session
+
+_JWT_SECRET = "dataclaw-jwt-secret-change-in-production"
+_JWT_ALGORITHM = "HS256"
+_JWT_EXPIRE_HOURS = 24
+
+_bearer = HTTPBearer(auto_error=False)
+
+
+def configure_jwt(secret: str, algorithm: str = "HS256", expire_hours: int = 24):
+    global _JWT_SECRET, _JWT_ALGORITHM, _JWT_EXPIRE_HOURS
+    _JWT_SECRET = secret
+    _JWT_ALGORITHM = algorithm
+    _JWT_EXPIRE_HOURS = expire_hours
+
+
+def create_access_token(agent_id: str, extra: dict = None) -> str:
+    payload = {
+        "sub": agent_id,
+        "iat": datetime.now(timezone.utc),
+        "exp": datetime.now(timezone.utc) + timedelta(hours=_JWT_EXPIRE_HOURS),
+    }
+    if extra:
+        payload.update(extra)
+    return jwt.encode(payload, _JWT_SECRET, algorithm=_JWT_ALGORITHM)
+
+
+def decode_access_token(token: str) -> Optional[dict]:
+    try:
+        return jwt.decode(token, _JWT_SECRET, algorithms=[_JWT_ALGORITHM])
+    except Exception:
+        return None
+
+
+async def _resolve_api_key(api_key: str, session: AsyncSession) -> Optional[str]:
+    from utils.crypto import hash_api_key
+    key_hash = hash_api_key(api_key)
+    row = await session.execute(
+        text("SELECT agent_id FROM api_keys WHERE key_hash=:h AND status='active' LIMIT 1"),
+        {"h": key_hash}
+    )
+    result = row.fetchone()
+    if result:
+        await session.execute(
+            text("UPDATE api_keys SET last_used_at=NOW() WHERE key_hash=:h"),
+            {"h": key_hash}
+        )
+        await session.commit()
+        return result[0]
+    return None
+
+
+async def get_current_agent(
+    request: Request,
+    credentials: Optional[HTTPAuthorizationCredentials] = Depends(_bearer),
+    session: AsyncSession = Depends(get_session),
+) -> Optional[str]:
+    token = None
+    if credentials:
+        token = credentials.credentials
+    else:
+        token = request.query_params.get("api_key") or request.cookies.get("dc_api_key")
+    if not token:
+        return None
+    payload = decode_access_token(token)
+    if payload:
+        return payload.get("sub")
+    if token.startswith("dc_"):
+        return await _resolve_api_key(token, session)
+    return None
+
+
+async def require_auth(
+    agent_id: Optional[str] = Depends(get_current_agent),
+) -> str:
+    if not agent_id:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail={"ok": False, "error": "AUTH_REQUIRED", "message": "需要认证",
+                    "_discovery": {"entry": "/.well-known/agent-data-exchange.json"}},
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+    return agent_id