@agentunion/kite 1.4.0 → 1.6.0

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

@@ -0,0 +1,177 @@
+"""
+积分系统 API
+"""
+from typing import Optional
+
+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_uuid
+
+router = APIRouter()
+DISC = {"entry": "/.well-known/agent-data-exchange.json"}
+
+
+class DepositRequest(BaseModel):
+    amount: float
+    channel: str = "alipay"  # alipay / wechat / stripe / paypal
+    return_url: str = ""
+
+
+@router.get("/balance")
+async def get_balance(
+    agent_id: str = Depends(require_auth),
+    session: AsyncSession = Depends(get_session)
+):
+    row = (await session.execute(
+        text("SELECT credits FROM agents WHERE id=:id"), {"id": agent_id}
+    )).fetchone()
+    if not row:
+        raise HTTPException(404, detail={"ok": False, "error": "NOT_FOUND"})
+    return {"ok": True, "data": {"balance": float(row.credits), "unit": "credit"}, "_discovery": DISC}
+
+
+@router.get("/history")
+async def get_history(
+    type: Optional[str] = Query(None, description="deposit/earn/spend/refund/bonus"),
+    limit: int = Query(50, ge=1, le=200),
+    offset: int = Query(0, ge=0),
+    agent_id: str = Depends(require_auth),
+    session: AsyncSession = Depends(get_session)
+):
+    conditions = ["agent_id=:aid"]
+    params = {"aid": agent_id, "lim": limit, "off": offset}
+    if type:
+        conditions.append("type=:type")
+        params["type"] = type
+    where = " AND ".join(conditions)
+    rows = (await session.execute(
+        text(f"SELECT id, type, amount, balance_after, related_feed_id, description, created_at "
+             f"FROM credit_transactions WHERE {where} ORDER BY created_at DESC LIMIT :lim OFFSET :off"),
+        params
+    )).fetchall()
+    total = (await session.execute(
+        text(f"SELECT COUNT(*) FROM credit_transactions WHERE {where}"),
+        {k: v for k, v in params.items() if k not in ('lim', 'off')}
+    )).scalar()
+    txs = []
+    for r in rows:
+        txs.append({
+            "id": r.id, "type": r.type, "amount": float(r.amount),
+            "balance_after": float(r.balance_after) if r.balance_after else None,
+            "related_feed_id": r.related_feed_id,
+            "description": r.description,
+            "created_at": r.created_at.isoformat() if r.created_at else None
+        })
+    return {"ok": True, "data": {"transactions": txs, "total": total,
+                                  "limit": limit, "offset": offset}, "_discovery": DISC}
+
+
+@router.get("/earnings")
+async def get_earnings(
+    agent_id: str = Depends(require_auth),
+    session: AsyncSession = Depends(get_session)
+):
+    """贡献者收入报表（按接口分组）"""
+    rows = (await session.execute(
+        text("""
+            SELECT t.related_feed_id AS feed_id, f.name AS feed_name,
+                   COUNT(*) AS tx_count,
+                   SUM(t.amount) AS total_earned
+            FROM credit_transactions t
+            LEFT JOIN feeds f ON f.id = t.related_feed_id
+            WHERE t.agent_id=:aid AND t.type='earn'
+            GROUP BY t.related_feed_id, f.name
+            ORDER BY total_earned DESC
+        """),
+        {"aid": agent_id}
+    )).fetchall()
+    # 总收入
+    total_earned = (await session.execute(
+        text("SELECT COALESCE(SUM(amount), 0) FROM credit_transactions "
+             "WHERE agent_id=:aid AND type='earn'"),
+        {"aid": agent_id}
+    )).scalar()
+    # 总支出
+    total_spent = (await session.execute(
+        text("SELECT COALESCE(SUM(ABS(amount)), 0) FROM credit_transactions "
+             "WHERE agent_id=:aid AND type='spend'"),
+        {"aid": agent_id}
+    )).scalar()
+    by_feed = []
+    for r in rows:
+        by_feed.append({
+            "feed_id": r.feed_id, "feed_name": r.feed_name,
+            "tx_count": r.tx_count, "total_earned": float(r.total_earned or 0)
+        })
+    return {"ok": True, "data": {
+        "total_earned": float(total_earned or 0),
+        "total_spent": float(total_spent or 0),
+        "by_feed": by_feed
+    }, "_discovery": DISC}
+
+
+@router.post("/deposit")
+async def create_deposit(
+    body: DepositRequest,
+    agent_id: str = Depends(require_auth),
+    session: AsyncSession = Depends(get_session)
+):
+    """发起充值（返回支付链接/信息）"""
+    if body.amount <= 0:
+        raise HTTPException(400, detail={"ok": False, "error": "INVALID_AMOUNT",
+                                          "message": "金额必须大于 0", "_discovery": DISC})
+    # 记录待处理充值
+    tx_id = gen_uuid()[:32]
+    # TODO: 接入支付宝/微信/Stripe/PayPal
+    payment_url = f"https://pay.dataclaw.io/checkout/{tx_id}?channel={body.channel}&amount={body.amount}"
+    rmb_amount = body.amount / 100  # 100 积分 = 1 元
+    return {"ok": True, "data": {
+        "transaction_id": tx_id,
+        "credits": body.amount,
+        "rmb_amount": rmb_amount,
+        "channel": body.channel,
+        "payment_url": payment_url,
+        "expires_in": 1800,
+        "message": f"请在 30 分钟内完成支付，共 {rmb_amount:.2f} 元"
+    }, "_discovery": DISC}
+
+
+@router.get("/estimate")
+async def estimate_cost(
+    feed_id: str = Query(...),
+    action: str = Query("query", description="query/subscribe"),
+    session: AsyncSession = Depends(get_session)
+):
+    """预估某次操作的积分消耗"""
+    row = (await session.execute(
+        text("SELECT token_cost, subscriber_count, pricing FROM feeds WHERE id=:fid"),
+        {"fid": feed_id}
+    )).fetchone()
+    if not row:
+        raise HTTPException(404, detail={"ok": False, "error": "FEED_NOT_FOUND", "_discovery": DISC})
+    # 三阶段定价
+    n = row.subscriber_count or 1
+    base_cost = row.token_cost or 1000
+    # 成本折算：1 token ~ 0.0000002 积分（Claude Haiku 定价）
+    collect_cost = base_cost * 0.0000002 * 5000  # 约 1 积分/次
+    commission = 0.15  # 15% 抽成
+    # 规模定价算法
+    if n < 30:
+        price_per_use = round(collect_cost * 0.42, 4)
+    elif n < 300:
+        price_per_use = round(collect_cost * 0.15, 4)
+    else:
+        price_per_use = round(collect_cost * 0.05, 4)
+    price_per_use = max(price_per_use, 0.01)
+    return {"ok": True, "data": {
+        "feed_id": feed_id, "action": action,
+        "estimated_cost": price_per_use,
+        "unit": "credit/call",
+        "subscriber_count": n,
+        "note": "价格随订阅人数增加而降低"
+    }, "_discovery": DISC}

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

@@ -0,0 +1,179 @@
+"""
+数据读写 API — Feed 数据版本管理
+"""
+import json
+from typing import Optional
+
+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, get_current_agent
+from core.database import get_session
+
+router = APIRouter()
+DISC = {"entry": "/.well-known/agent-data-exchange.json"}
+
+
+class PublishDataRequest(BaseModel):
+    data: dict
+    summary: str = ""
+    diff_summary: str = ""
+    meta: dict = {}
+
+
+@router.post("/{feed_id}/data")
+async def publish_data(
+    feed_id: str,
+    body: PublishDataRequest,
+    agent_id: str = Depends(require_auth),
+    session: AsyncSession = Depends(get_session)
+):
+    """贡献者提交新版本数据"""
+    row = (await session.execute(
+        text("SELECT owner_id, collaborators, schema_def FROM feeds WHERE id=:id AND status='active'"),
+        {"id": feed_id}
+    )).fetchone()
+    if not row:
+        raise HTTPException(404, detail={"ok": False, "error": "FEED_NOT_FOUND", "_discovery": DISC})
+    collabs = row.collaborators or []
+    if agent_id != row.owner_id and agent_id not in collabs:
+        raise HTTPException(403, detail={"ok": False, "error": "FORBIDDEN",
+                                          "message": "仅 owner/collaborator 可提交数据", "_discovery": DISC})
+    # 获取下一个版本号
+    ver_row = (await session.execute(
+        text("SELECT COALESCE(MAX(version_num), 0) + 1 AS next_ver FROM feed_versions WHERE feed_id=:id"),
+        {"id": feed_id}
+    )).fetchone()
+    next_ver = ver_row.next_ver if ver_row else 1
+    data_str = json.dumps(body.data, ensure_ascii=False)
+    size_bytes = len(data_str.encode())
+    await session.execute(
+        text("""
+            INSERT INTO feed_versions (feed_id, version_num, data, summary, diff_summary, meta, size_bytes)
+            VALUES (:fid, :ver, :data, :summary, :diff, :meta, :size)
+        """),
+        {"fid": feed_id, "ver": next_ver, "data": data_str,
+         "summary": body.summary, "diff": body.diff_summary,
+         "meta": json.dumps(body.meta), "size": size_bytes}
+    )
+    await session.execute(
+        text("UPDATE feeds SET last_data_at=NOW(), total_queries=total_queries+1 WHERE id=:id"),
+        {"id": feed_id}
+    )
+    await session.commit()
+    return {"ok": True, "data": {"feed_id": feed_id, "version": next_ver,
+                                  "size_bytes": size_bytes, "message": "数据提交成功"}, "_discovery": DISC}
+
+
+@router.get("/{feed_id}/data/latest")
+async def get_latest(
+    feed_id: str,
+    agent_id: Optional[str] = Depends(get_current_agent),
+    session: AsyncSession = Depends(get_session)
+):
+    """获取最新版本数据（消耗积分）"""
+    if not agent_id:
+        raise HTTPException(401, detail={"ok": False, "error": "AUTH_REQUIRED",
+                                          "message": "获取数据需要认证", "_discovery": DISC})
+    row = (await session.execute(
+        text("SELECT id, version_num, data, summary, diff_summary, meta, size_bytes, created_at "
+             "FROM feed_versions WHERE feed_id=:fid ORDER BY version_num DESC LIMIT 1"),
+        {"fid": feed_id}
+    )).fetchone()
+    if not row:
+        raise HTTPException(404, detail={"ok": False, "error": "NO_DATA",
+                                          "message": "该接口暂无数据", "_discovery": DISC})
+    return {"ok": True, "data": {
+        "feed_id": feed_id, "version": row.version_num,
+        "data": row.data, "summary": row.summary,
+        "diff_summary": row.diff_summary, "meta": row.meta,
+        "size_bytes": row.size_bytes,
+        "timestamp": row.created_at.isoformat() if row.created_at else None
+    }, "_discovery": DISC}
+
+
+@router.get("/{feed_id}/data/versions")
+async def list_versions(
+    feed_id: str,
+    limit: int = Query(20, ge=1, le=100),
+    offset: int = Query(0, ge=0),
+    agent_id: Optional[str] = Depends(get_current_agent),
+    session: AsyncSession = Depends(get_session)
+):
+    """获取版本列表（仅元信息，不含数据体）"""
+    if not agent_id:
+        raise HTTPException(401, detail={"ok": False, "error": "AUTH_REQUIRED", "_discovery": DISC})
+    rows = (await session.execute(
+        text("SELECT version_num, summary, size_bytes, created_at "
+             "FROM feed_versions WHERE feed_id=:fid ORDER BY version_num DESC LIMIT :lim OFFSET :off"),
+        {"fid": feed_id, "lim": limit, "off": offset}
+    )).fetchall()
+    total = (await session.execute(
+        text("SELECT COUNT(*) FROM feed_versions WHERE feed_id=:fid"), {"fid": feed_id}
+    )).scalar()
+    versions = [
+        {"version": r.version_num, "summary": r.summary,
+         "size_bytes": r.size_bytes,
+         "timestamp": r.created_at.isoformat() if r.created_at else None}
+        for r in rows
+    ]
+    return {"ok": True, "data": {"versions": versions, "total": total,
+                                  "limit": limit, "offset": offset}, "_discovery": DISC}
+
+
+@router.get("/{feed_id}/data/versions/{version}")
+async def get_version(
+    feed_id: str,
+    version: int,
+    agent_id: Optional[str] = Depends(get_current_agent),
+    session: AsyncSession = Depends(get_session)
+):
+    """获取指定版本数据"""
+    if not agent_id:
+        raise HTTPException(401, detail={"ok": False, "error": "AUTH_REQUIRED", "_discovery": DISC})
+    row = (await session.execute(
+        text("SELECT version_num, data, summary, diff_summary, meta, size_bytes, created_at "
+             "FROM feed_versions WHERE feed_id=:fid AND version_num=:ver"),
+        {"fid": feed_id, "ver": version}
+    )).fetchone()
+    if not row:
+        raise HTTPException(404, detail={"ok": False, "error": "VERSION_NOT_FOUND",
+                                          "message": f"版本 {version} 不存在", "_discovery": DISC})
+    return {"ok": True, "data": {
+        "feed_id": feed_id, "version": row.version_num,
+        "data": row.data, "summary": row.summary,
+        "diff_summary": row.diff_summary, "meta": row.meta,
+        "size_bytes": row.size_bytes,
+        "timestamp": row.created_at.isoformat() if row.created_at else None
+    }, "_discovery": DISC}
+
+
+@router.delete("/{feed_id}/data/versions/{version}")
+async def delete_version(
+    feed_id: str,
+    version: int,
+    agent_id: str = Depends(require_auth),
+    session: AsyncSession = Depends(get_session)
+):
+    """删除指定版本（仅 owner 可操作）"""
+    feed_row = (await session.execute(
+        text("SELECT owner_id FROM feeds WHERE id=:id AND status='active'"),
+        {"id": feed_id}
+    )).fetchone()
+    if not feed_row:
+        raise HTTPException(404, detail={"ok": False, "error": "FEED_NOT_FOUND", "_discovery": DISC})
+    if agent_id != feed_row.owner_id:
+        raise HTTPException(403, detail={"ok": False, "error": "FORBIDDEN",
+                                          "message": "仅 owner 可删除版本", "_discovery": DISC})
+    result = await session.execute(
+        text("DELETE FROM feed_versions WHERE feed_id=:fid AND version_num=:ver"),
+        {"fid": feed_id, "ver": version}
+    )
+    if result.rowcount == 0:
+        raise HTTPException(404, detail={"ok": False, "error": "VERSION_NOT_FOUND",
+                                          "message": f"版本 {version} 不存在", "_discovery": DISC})
+    await session.commit()
+    return {"ok": True, "data": {"feed_id": feed_id, "version": version,
+                                  "message": "版本已删除"}, "_discovery": DISC}

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

@@ -0,0 +1,269 @@
+"""
+需求驱动 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, get_current_agent
+from core.database import get_session
+from utils.id_generator import gen_demand_id
+
+router = APIRouter()
+DISC = {"entry": "/.well-known/agent-data-exchange.json"}
+
+
+class CreateDemandRequest(BaseModel):
+    title: str
+    description: str = ""
+    desired_schema: dict = {}
+    desired_update_cycle: str = "1h"
+    budget_hint: str = ""
+    category: List[str] = []
+
+
+class UpdateDemandRequest(BaseModel):
+    title: Optional[str] = None
+    description: Optional[str] = None
+    budget_hint: Optional[str] = None
+
+
+class FulfillRequest(BaseModel):
+    feed_id: str
+    match_score: float = 1.0
+    note: str = ""
+
+
+@router.get("")
+async def list_demands(
+    sort: str = Query("hot", description="hot/new"),
+    status: str = Query("open"),
+    limit: int = Query(20, ge=1, le=100),
+    offset: int = Query(0, ge=0),
+    session: AsyncSession = Depends(get_session)
+):
+    order = "d.upvotes DESC, d.created_at DESC" if sort == "hot" else "d.created_at DESC"
+    params = {"status": status, "lim": limit, "off": offset}
+    rows = (await session.execute(
+        text(f"""
+            SELECT d.id, d.title, d.description, d.desired_update_cycle,
+                   d.budget_hint, d.category, d.upvotes, d.subscriber_count,
+                   d.status, d.fulfilled_by, d.created_at, a.name AS creator_name
+            FROM demands d
+            LEFT JOIN agents a ON a.id = d.created_by
+            WHERE d.status = :status
+            ORDER BY {order}
+            LIMIT :lim OFFSET :off
+        """),
+        params
+    )).fetchall()
+    total = (await session.execute(
+        text("SELECT COUNT(*) FROM demands WHERE status=:status"), {"status": status}
+    )).scalar()
+    demands = []
+    for r in rows:
+        demands.append({
+            "id": r.id, "title": r.title, "description": r.description,
+            "desired_update_cycle": r.desired_update_cycle,
+            "budget_hint": r.budget_hint, "category": r.category,
+            "upvotes": r.upvotes, "subscriber_count": r.subscriber_count,
+            "status": r.status, "fulfilled_by": r.fulfilled_by or [],
+            "creator_name": r.creator_name,
+            "created_at": r.created_at.isoformat() if r.created_at else None
+        })
+    return {"ok": True, "data": {"demands": demands, "total": total,
+                                  "limit": limit, "offset": offset}, "_discovery": DISC}
+
+
+@router.post("")
+async def create_demand(
+    body: CreateDemandRequest,
+    agent_id: str = Depends(require_auth),
+    session: AsyncSession = Depends(get_session)
+):
+    import json
+    demand_id = gen_demand_id()
+    await session.execute(
+        text("""
+            INSERT INTO demands (id, title, description, desired_schema, desired_update_cycle,
+                budget_hint, category, created_by, status)
+            VALUES (:id, :title, :desc, :schema, :cycle, :budget, :cat, :creator, 'open')
+        """),
+        {
+            "id": demand_id, "title": body.title, "desc": body.description,
+            "schema": json.dumps(body.desired_schema), "cycle": body.desired_update_cycle,
+            "budget": body.budget_hint, "cat": json.dumps(body.category), "creator": agent_id
+        }
+    )
+    await session.commit()
+    return {"ok": True, "data": {"id": demand_id}, "_discovery": DISC}
+
+
+@router.get("/{demand_id}")
+async def get_demand(
+    demand_id: str,
+    session: AsyncSession = Depends(get_session)
+):
+    row = (await session.execute(
+        text("""
+            SELECT d.id, d.title, d.description, d.desired_schema, d.desired_update_cycle,
+                   d.budget_hint, d.category, d.upvotes, d.subscriber_count,
+                   d.status, d.fulfilled_by, d.created_at, a.name AS creator_name
+            FROM demands d
+            LEFT JOIN agents a ON a.id = d.created_by
+            WHERE d.id = :did
+        """),
+        {"did": demand_id}
+    )).fetchone()
+    if not row:
+        raise HTTPException(status_code=404, detail="Demand not found")
+    return {
+        "ok": True,
+        "data": {
+            "id": row.id, "title": row.title, "description": row.description,
+            "desired_schema": row.desired_schema, "desired_update_cycle": row.desired_update_cycle,
+            "budget_hint": row.budget_hint, "category": row.category,
+            "upvotes": row.upvotes, "subscriber_count": row.subscriber_count,
+            "status": row.status, "fulfilled_by": row.fulfilled_by or [],
+            "creator_name": row.creator_name,
+            "created_at": row.created_at.isoformat() if row.created_at else None
+        },
+        "_discovery": DISC
+    }
+
+
+@router.patch("/{demand_id}")
+async def update_demand(
+    demand_id: str,
+    body: UpdateDemandRequest,
+    agent_id: str = Depends(require_auth),
+    session: AsyncSession = Depends(get_session)
+):
+    row = (await session.execute(
+        text("SELECT created_by FROM demands WHERE id=:did"), {"did": demand_id}
+    )).fetchone()
+    if not row:
+        raise HTTPException(status_code=404, detail="Demand not found")
+    if row.created_by != agent_id:
+        raise HTTPException(status_code=403, detail="Not your demand")
+    updates = {k: v for k, v in body.dict().items() if v is not None}
+    if not updates:
+        return {"ok": True, "data": {"id": demand_id}, "_discovery": DISC}
+    set_clause = ", ".join(f"{k}=:{k}" for k in updates)
+    updates["did"] = demand_id
+    await session.execute(
+        text(f"UPDATE demands SET {set_clause} WHERE id=:did"), updates
+    )
+    await session.commit()
+    return {"ok": True, "data": {"id": demand_id}, "_discovery": DISC}
+
+
+@router.delete("/{demand_id}")
+async def delete_demand(
+    demand_id: str,
+    agent_id: str = Depends(require_auth),
+    session: AsyncSession = Depends(get_session)
+):
+    row = (await session.execute(
+        text("SELECT created_by FROM demands WHERE id=:did"), {"did": demand_id}
+    )).fetchone()
+    if not row:
+        raise HTTPException(status_code=404, detail="Demand not found")
+    if row.created_by != agent_id:
+        raise HTTPException(status_code=403, detail="Not your demand")
+    await session.execute(
+        text("DELETE FROM demands WHERE id=:did"), {"did": demand_id}
+    )
+    await session.commit()
+    return {"ok": True, "data": {"deleted": demand_id}, "_discovery": DISC}
+
+
+@router.post("/{demand_id}/upvote")
+async def upvote_demand(
+    demand_id: str,
+    agent_id: str = Depends(require_auth),
+    session: AsyncSession = Depends(get_session)
+):
+    exists = (await session.execute(
+        text("SELECT id FROM demands WHERE id=:did"), {"did": demand_id}
+    )).fetchone()
+    if not exists:
+        raise HTTPException(status_code=404, detail="Demand not found")
+    already = (await session.execute(
+        text("SELECT 1 FROM demand_upvotes WHERE demand_id=:did AND agent_id=:aid"),
+        {"did": demand_id, "aid": agent_id}
+    )).fetchone()
+    if already:
+        return {"ok": True, "data": {"id": demand_id, "message": "already upvoted"}, "_discovery": DISC}
+    await session.execute(
+        text("INSERT INTO demand_upvotes (demand_id, agent_id) VALUES (:did, :aid)"),
+        {"did": demand_id, "aid": agent_id}
+    )
+    await session.execute(
+        text("UPDATE demands SET upvotes = (SELECT COUNT(*) FROM demand_upvotes WHERE demand_id=:did) WHERE id=:did"),
+        {"did": demand_id}
+    )
+    await session.commit()
+    return {"ok": True, "data": {"id": demand_id}, "_discovery": DISC}
+
+
+@router.post("/{demand_id}/subscribe")
+async def subscribe_demand(
+    demand_id: str,
+    agent_id: str = Depends(require_auth),
+    session: AsyncSession = Depends(get_session)
+):
+    exists = (await session.execute(
+        text("SELECT id FROM demands WHERE id=:did"), {"did": demand_id}
+    )).fetchone()
+    if not exists:
+        raise HTTPException(status_code=404, detail="Demand not found")
+    await session.execute(
+        text("""
+            INSERT IGNORE INTO demand_subscriptions (demand_id, agent_id)
+            VALUES (:did, :aid)
+        """),
+        {"did": demand_id, "aid": agent_id}
+    )
+    await session.execute(
+        text("""
+            UPDATE demands SET subscriber_count = (
+                SELECT COUNT(*) FROM demand_subscriptions WHERE demand_id=:did
+            ) WHERE id=:did
+        """),
+        {"did": demand_id}
+    )
+    await session.commit()
+    return {"ok": True, "data": {"id": demand_id}, "_discovery": DISC}
+
+
+@router.post("/{demand_id}/fulfill")
+async def fulfill_demand(
+    demand_id: str,
+    body: FulfillRequest,
+    agent_id: str = Depends(require_auth),
+    session: AsyncSession = Depends(get_session)
+):
+    exists = (await session.execute(
+        text("SELECT id FROM demands WHERE id=:did"), {"did": demand_id}
+    )).fetchone()
+    if not exists:
+        raise HTTPException(status_code=404, detail="Demand not found")
+    import json
+    row = (await session.execute(
+        text("SELECT fulfilled_by FROM demands WHERE id=:did"), {"did": demand_id}
+    )).fetchone()
+    fulfilled_by = row.fulfilled_by or []
+    entry = {"feed_id": body.feed_id, "agent_id": agent_id,
+             "match_score": body.match_score, "note": body.note}
+    if not any(e["feed_id"] == body.feed_id for e in fulfilled_by):
+        fulfilled_by.append(entry)
+    await session.execute(
+        text("UPDATE demands SET fulfilled_by=:fb, status='fulfilled' WHERE id=:did"),
+        {"fb": json.dumps(fulfilled_by), "did": demand_id}
+    )
+    await session.commit()
+    return {"ok": True, "data": {"id": demand_id, "fulfilled_by": fulfilled_by}, "_discovery": DISC}