Agent/knowhub/server.py

"""
KnowHub Server

Agent 工具使用经验的共享平台。
FastAPI + Milvus Lite（知识）+ SQLite（资源），单文件部署。
"""

import os
import re
import json
import asyncio
import base64
import time
import uuid
from contextlib import asynccontextmanager
from datetime import datetime, timezone
from typing import Optional, List, Dict
from pathlib import Path
from cryptography.hazmat.primitives.ciphers.aead import AESGCM

from fastapi import FastAPI, HTTPException, Query, Header, Body, BackgroundTasks
from fastapi.responses import HTMLResponse
from pydantic import BaseModel, Field

# 导入 LLM 调用（需要 agent 模块在 Python path 中）
import sys
sys.path.insert(0, str(Path(__file__).parent.parent))

# 加载环境变量
from dotenv import load_dotenv
load_dotenv(Path(__file__).parent.parent / ".env")

from agent.llm import create_openrouter_llm_call, create_qwen_llm_call

_dedup_llm = create_openrouter_llm_call(model="google/gemini-2.5-flash-lite")
_tool_analysis_llm = create_qwen_llm_call(model="qwen3.5-plus")

# 导入向量存储和 embedding
from knowhub.knowhub_db.pg_store import PostgreSQLStore
from knowhub.knowhub_db.pg_resource_store import PostgreSQLResourceStore
from knowhub.embeddings import get_embedding, get_embeddings_batch

BRAND_NAME    = os.getenv("BRAND_NAME", "KnowHub")
BRAND_API_ENV = os.getenv("BRAND_API_ENV", "KNOWHUB_API")
BRAND_DB      = os.getenv("BRAND_DB", "knowhub.db")

# 组织密钥配置（格式：org1:key1_base64,org2:key2_base64）
ORG_KEYS_RAW = os.getenv("ORG_KEYS", "")
ORG_KEYS = {}
if ORG_KEYS_RAW:
    for pair in ORG_KEYS_RAW.split(","):
        if ":" in pair:
            org, key_b64 = pair.split(":", 1)
            ORG_KEYS[org.strip()] = key_b64.strip()

DB_PATH = Path(__file__).parent / BRAND_DB

# 全局 PostgreSQL 存储实例
pg_store: Optional[PostgreSQLStore] = None
pg_resource_store: Optional[PostgreSQLResourceStore] = None

# --- 加密/解密 ---

def get_org_key(resource_id: str) -> Optional[bytes]:
    """从content_id提取组织前缀，返回对应密钥"""
    if "/" in resource_id:
        org = resource_id.split("/")[0]
        if org in ORG_KEYS:
            return base64.b64decode(ORG_KEYS[org])
    return None


def encrypt_content(resource_id: str, plaintext: str) -> str:
    """加密内容，返回格式：encrypted:AES256-GCM:{base64_data}"""
    if not plaintext:
        return ""

    key = get_org_key(resource_id)
    if not key:
        # 没有配置密钥，明文存储（不推荐）
        return plaintext

    aesgcm = AESGCM(key)
    nonce = os.urandom(12)  # 96-bit nonce
    ciphertext = aesgcm.encrypt(nonce, plaintext.encode("utf-8"), None)

    # 组合 nonce + ciphertext
    encrypted_data = nonce + ciphertext
    encoded = base64.b64encode(encrypted_data).decode("ascii")

    return f"encrypted:AES256-GCM:{encoded}"


def decrypt_content(resource_id: str, encrypted_text: str, provided_key: Optional[str] = None) -> str:
    """解密内容，如果没有提供密钥或密钥错误，返回[ENCRYPTED]"""
    if not encrypted_text:
        return ""

    if not encrypted_text.startswith("encrypted:AES256-GCM:"):
        # 未加密的内容，直接返回
        return encrypted_text

    # 提取加密数据
    encoded = encrypted_text.split(":", 2)[2]
    encrypted_data = base64.b64decode(encoded)

    nonce = encrypted_data[:12]
    ciphertext = encrypted_data[12:]

    # 获取密钥
    key = None
    if provided_key:
        # 使用提供的密钥
        try:
            key = base64.b64decode(provided_key)
        except Exception:
            return "[ENCRYPTED]"
    else:
        # 从配置中获取
        key = get_org_key(resource_id)

    if not key:
        return "[ENCRYPTED]"

    try:
        aesgcm = AESGCM(key)
        plaintext = aesgcm.decrypt(nonce, ciphertext, None)
        return plaintext.decode("utf-8")
    except Exception:
        return "[ENCRYPTED]"


def serialize_milvus_result(data):
    """将 Milvus 返回的数据转换为可序列化的字典"""
    # 基本类型直接返回
    if data is None or isinstance(data, (str, int, float, bool)):
        return data

    # 字典类型递归处理
    if isinstance(data, dict):
        return {k: serialize_milvus_result(v) for k, v in data.items()}

    # 列表/元组类型递归处理
    if isinstance(data, (list, tuple)):
        return [serialize_milvus_result(item) for item in data]

    # 尝试转换为字典（对于有 to_dict 方法的对象）
    if hasattr(data, 'to_dict') and callable(getattr(data, 'to_dict')):
        try:
            return serialize_milvus_result(data.to_dict())
        except:
            pass

    # 尝试转换为列表（对于可迭代对象，如 RepeatedScalarContainer）
    if hasattr(data, '__iter__') and not isinstance(data, (str, bytes, dict)):
        try:
            # 强制转换为列表并递归处理
            result = []
            for item in data:
                result.append(serialize_milvus_result(item))
            return result
        except:
            pass

    # 尝试获取对象的属性字典
    if hasattr(data, '__dict__'):
        try:
            return serialize_milvus_result(vars(data))
        except:
            pass

    # 最后的 fallback：对于无法处理的类型，返回 None 而不是字符串表示
    # 这样可以避免产生无法序列化的字符串
    return None


# --- Models ---

class ResourceIn(BaseModel):
    id: str
    title: str = ""
    body: str
    secure_body: str = ""
    content_type: str = "text"  # text|code|credential|cookie
    metadata: dict = {}
    sort_order: int = 0
    submitted_by: str = ""


class ResourcePatchIn(BaseModel):
    """PATCH /api/resource/{id} 请求体"""
    title: Optional[str] = None
    body: Optional[str] = None
    secure_body: Optional[str] = None
    content_type: Optional[str] = None
    metadata: Optional[dict] = None


# Knowledge Models
class KnowledgeIn(BaseModel):
    task: str
    content: str
    types: list[str] = ["strategy"]
    tags: dict = {}
    scopes: list[str] = ["org:cybertogether"]
    owner: str = ""
    message_id: str = ""
    resource_ids: list[str] = []
    source: dict = {}  # {name, category, urls, agent_id, submitted_by, timestamp}
    eval: dict = {}    # {score, helpful, harmful, confidence}


class KnowledgeOut(BaseModel):
    id: str
    message_id: str
    types: list[str]
    task: str
    tags: dict
    scopes: list[str]
    owner: str
    content: str
    resource_ids: list[str]
    source: dict
    eval: dict
    created_at: str
    updated_at: str


class KnowledgeUpdateIn(BaseModel):
    add_helpful_case: Optional[dict] = None
    add_harmful_case: Optional[dict] = None
    update_score: Optional[int] = Field(default=None, ge=1, le=5)
    evolve_feedback: Optional[str] = None


class KnowledgePatchIn(BaseModel):
    """PATCH /api/knowledge/{id} 请求体（直接字段编辑）"""
    task: Optional[str] = None
    content: Optional[str] = None
    types: Optional[list[str]] = None
    tags: Optional[dict] = None
    scopes: Optional[list[str]] = None
    owner: Optional[str] = None


class MessageExtractIn(BaseModel):
    """POST /api/extract 请求体（消息历史提取）"""
    messages: list[dict]  # [{role: str, content: str}, ...]
    agent_id: str = "unknown"
    submitted_by: str  # 必填，作为 owner
    session_key: str = ""


class KnowledgeBatchUpdateIn(BaseModel):
    feedback_list: list[dict]



class KnowledgeVerifyIn(BaseModel):
    action: str  # "approve" | "reject"
    verified_by: str = "user"


class KnowledgeBatchVerifyIn(BaseModel):
    knowledge_ids: List[str]
    action: str  # "approve"
    verified_by: str


class KnowledgeSearchResponse(BaseModel):
    results: list[dict]
    count: int


class ResourceNode(BaseModel):
    id: str
    title: str


class ResourceOut(BaseModel):
    id: str
    title: str
    body: str
    secure_body: str = ""
    content_type: str = "text"
    metadata: dict = {}
    toc: Optional[ResourceNode] = None
    children: list[ResourceNode]
    prev: Optional[ResourceNode] = None
    next: Optional[ResourceNode] = None


# --- Dedup: Globals & Prompt ---

knowledge_processor: Optional["KnowledgeProcessor"] = None

DEDUP_RELATION_PROMPT = """你是知识库管理专家。请判断【新知识】与【相似知识列表】中每条知识的关系。

【新知识】
Task: {new_task}
Content: {new_content}

【相似知识列表】（向量召回 top-10，按相似度排序）
{existing_list}
格式: [序号] ID: xxx | Task: xxx | Content: xxx

【关系类型定义】
- duplicate: task 和 content 语义完全相同，无新增信息 → 新知识应 rejected
- subset: task语义一致，新知识的content信息完全被某条已有知识覆盖 → 新知识应 rejected
- superset: task语义一致，新知识包含某条已有知识的全部信息，且有额外内容 → 新知识应 approved
- conflict: 同一 task 下给出相互矛盾的结论 → 新知识应 approved
- complement: 描述同一 task 的不同方面，互补 → 新知识应 approved
- none: task 语义不同，或无实质关系 → 新知识应 approved，不写入 relations

【判断步骤】
第一步：逐条比较新知识的 task 与列表中每条知识的 task 语义是否一致。
- task 语义一致 = 两者描述的是同一个问题或目标（即使措辞不同）
- task 语义不同 = 描述的是不同的问题、不同的工具、不同的场景
- 如果 task 语义不同，该条关系直接判定为 none，**不再看 content**
- 只有 task 语义一致时，才进入第二步比较 content

第二步：对 task 语义一致的知识，比较 content，判断具体关系类型（duplicate/subset/superset/conflict/complement）。

**规则**：
1. 如果以上类型无法准确描述，可自定义关系类型（英文小写下划线），并自行决定 approved/rejected
2. final_decision 为 rejected 时，relations 中必须至少有一条关系说明拒绝原因（type 不能为 none）

【输出格式】（严格 JSON，不要其他内容）

示例1 - 无关知识（task 不同）：
{{
  "final_decision": "approved",
  "relations": []
}}

示例2 - 重复知识：
{{
  "final_decision": "rejected",
  "relations": [
    {{
      "old_id": "knowledge-xxx",
      "type": "duplicate",
      "reverse_type": "duplicate"
    }}
  ]
}}

示例3 - 互补知识：
{{
  "final_decision": "approved",
  "relations": [
    {{
      "old_id": "knowledge-xxx",
      "type": "complement",
      "reverse_type": "complement"
    }}
  ]
}}

"""


TOOL_ANALYSIS_PROMPT = """\
分析以下知识条目，判断是否涉及"图像创作或解构任务中使用的工具"。

工具范畴（包括但不限于）：
- AI 生图平台/模型：Midjourney、Stable Diffusion、DALL-E、Flux、ComfyUI
- SD 插件/节点：ControlNet、IP-Adapter、InstantID、DWPose、DSINE
- 图像处理库：rembg、PIL/Pillow、OpenCV、scikit-image
- LoRA/checkpoint 模型、ComfyUI 自定义节点、AI 绘图辅助工具

知识条目：
task: {task}
content: {content}

要求：
- 如果涉及上述工具，提取每个工具的信息并以 JSON 格式返回。
- 如果不涉及任何工具，返回 {{"has_tools": false}}。
- 只输出 JSON，不要输出其他内容。

输出格式：
{{
  "has_tools": true,
  "tools": [
    {{
      "name": "工具名称（原名）",
      "slug": "小写英文短名，空格换下划线，如 controlnet、ip_adapter",
      "category": "image_gen | image_process | model | plugin | workflow | other",
      "version": "版本号或 null",
      "description": "一句话功能介绍",
      "usage": "核心用法",
      "scenarios": ["应用场景1", "应用场景2"],
      "input": "输入类型描述或 null",
      "output": "输出类型描述或 null",
      "source": "来源/文档链接或 null",
      "status": "未接入"
    }}
  ]
}}
"""


# --- Dedup: RelationCache ---

class RelationCache:
    """关系缓存，存储在内存中"""

    def __init__(self):
        self._cache: Dict[str, List[str]] = {}

    def load(self) -> dict:
        return self._cache

    def save(self, cache: dict):
        self._cache = cache

    def add_relation(self, relation_type: str, knowledge_id: str):
        if relation_type not in self._cache:
            self._cache[relation_type] = []
        if knowledge_id not in self._cache[relation_type]:
            self._cache[relation_type].append(knowledge_id)


# --- Dedup: KnowledgeProcessor ---

class KnowledgeProcessor:
    def __init__(self):
        self._lock = asyncio.Lock()
        self._relation_cache = RelationCache()

    async def process_pending(self):
        """持续处理 pending 和 dedup_passed 知识直到队列为空，有锁防并发"""
        if self._lock.locked():
            return
        async with self._lock:
            # 第一阶段：处理 pending（去重）
            while True:
                try:
                    pending = pg_store.query('status == "pending"', limit=50)
                except Exception as e:
                    print(f"[KnowledgeProcessor] 查询 pending 失败: {e}")
                    break
                if not pending:
                    break
                for knowledge in pending:
                    await self._process_one(knowledge)
            # 第二阶段：处理 dedup_passed（工具关联）
            while True:
                try:
                    dedup_passed = pg_store.query('status == "dedup_passed"', limit=50)
                except Exception as e:
                    print(f"[KnowledgeProcessor] 查询 dedup_passed 失败: {e}")
                    break
                if not dedup_passed:
                    break
                for knowledge in dedup_passed:
                    await self._analyze_tool_relation(knowledge)

    async def _process_one(self, knowledge: dict):
        kid = knowledge["id"]
        now = int(time.time())
        # 乐观锁：pending → processing（时间戳存秒级）
        try:
            pg_store.update(kid, {"status": "processing", "updated_at": now})
        except Exception as e:
            print(f"[KnowledgeProcessor] 锁定 {kid} 失败: {e}")
            return
        try:
            # 向量召回 top-10（只召回 approved/checked）
            embedding = knowledge.get("embedding")
            if not embedding:
                embedding = await get_embedding(knowledge["task"])
            candidates = pg_store.search(
                query_embedding=embedding,
                filters='(status == "approved" or status == "checked")',
                limit=10
            )
            candidates = [c for c in candidates if c["id"] != kid]
            # 只保留相似度 >= 0.75 的候选，低于阈值的 task 语义差异太大，直接视为 none
            candidates = [c for c in candidates if c.get("score", 0) >= 0.75]

            if not candidates:
                pg_store.update(kid, {"status": "dedup_passed", "updated_at": now})
                return

            llm_result = await self._llm_judge_relations(knowledge, candidates)
            await self._apply_decision(knowledge, llm_result)

        except Exception as e:
            print(f"[KnowledgeProcessor] 处理 {kid} 失败: {e}，回退到 pending")
            try:
                pg_store.update(kid, {"status": "pending", "updated_at": int(time.time())})
            except Exception:
                pass

    async def _llm_judge_relations(self, new_knowledge: dict, candidates: list) -> dict:
        existing_list = "\n".join([
            f"[{i+1}] ID: {c['id']} | Task: {c['task']} | Content: {c['content'][:300]}"
            for i, c in enumerate(candidates)
        ])
        prompt = DEDUP_RELATION_PROMPT.format(
            new_task=new_knowledge["task"],
            new_content=new_knowledge["content"],
            existing_list=existing_list
        )
        for attempt in range(3):
            try:
                response = await _dedup_llm(
                    messages=[{"role": "user", "content": prompt}],
                )
                content = response.get("content", "").strip()
                # 清理 markdown 代码块
                if "```" in content:
                    parts = content.split("```")
                    for part in parts:
                        part = part.strip()
                        if part.startswith("json"):
                            part = part[4:].strip()
                        try:
                            result = json.loads(part)
                            if "final_decision" in result:
                                content = part
                                break
                        except Exception:
                            continue
                result = json.loads(content)
                assert result.get("final_decision") in ("approved", "rejected")
                return result
            except Exception as e:
                print(f"[LLM Judge] 第{attempt+1}次失败: {e}")
                if attempt < 2:
                    await asyncio.sleep(1)
        return {"final_decision": "approved", "relations": []}

    async def _apply_decision(self, new_knowledge: dict, llm_result: dict):
        kid = new_knowledge["id"]
        final_decision = llm_result.get("final_decision", "approved")
        relations = llm_result.get("relations", [])
        now = int(time.time())

        # 强制规则：如果存在 duplicate 或 subset 关系，必须 rejected
        if any(rel.get("type") in ("duplicate", "subset") for rel in relations):
            final_decision = "rejected"

        if final_decision == "rejected":
            # 记录 rejected 知识的关系（便于溯源为什么被拒绝）
            rejected_relationships = []
            for rel in relations:
                old_id = rel.get("old_id")
                rel_type = rel.get("type", "none")
                if old_id and rel_type != "none":
                    rejected_relationships.append({"type": rel_type, "target": old_id})
                if rel_type in ("duplicate", "subset") and old_id:
                    try:
                        old = pg_store.get_by_id(old_id)
                        if not old:
                            continue
                        eval_data = old.get("eval") or {}
                        eval_data["helpful"] = eval_data.get("helpful", 0) + 1
                        helpful_history = eval_data.get("helpful_history") or []
                        helpful_history.append({
                            "source": "dedup",
                            "related_id": kid,
                            "relation_type": rel_type,
                            "timestamp": now
                        })
                        eval_data["helpful_history"] = helpful_history
                        pg_store.update(old_id, {"eval": eval_data, "updated_at": now})
                    except Exception as e:
                        print(f"[Apply Decision] 更新旧知识 {old_id} helpful 失败: {e}")
            pg_store.update(kid, {"status": "rejected", "relationships": json.dumps(rejected_relationships), "updated_at": now})
        else:
            new_relationships = []
            for rel in relations:
                rel_type = rel.get("type", "none")
                reverse_type = rel.get("reverse_type", "none")
                old_id = rel.get("old_id")
                if not old_id or rel_type == "none":
                    continue
                new_relationships.append({"type": rel_type, "target": old_id})
                self._relation_cache.add_relation(rel_type, kid)
                self._relation_cache.add_relation(rel_type, old_id)
                if reverse_type and reverse_type != "none":
                    try:
                        old = pg_store.get_by_id(old_id)
                        if old:
                            old_rels = old.get("relationships") or []
                            old_rels.append({"type": reverse_type, "target": kid})
                            pg_store.update(old_id, {"relationships": json.dumps(old_rels), "updated_at": now})
                            self._relation_cache.add_relation(reverse_type, old_id)
                            self._relation_cache.add_relation(reverse_type, kid)
                    except Exception as e:
                        print(f"[Apply Decision] 更新旧知识关系 {old_id} 失败: {e}")
            pg_store.update(kid, {
                "status": "dedup_passed",
                "relationships": json.dumps(new_relationships),
                "updated_at": now
            })

    async def _llm_analyze_tools(self, knowledge: dict) -> dict:
        """使用 LLM 分析知识中涉及的工具（复用迁移脚本逻辑）"""
        task = (knowledge.get("task") or "")[:600]
        content = (knowledge.get("content") or "")[:1200]
        prompt = TOOL_ANALYSIS_PROMPT.format(task=task, content=content)
        try:
            response = await _tool_analysis_llm(
                messages=[{"role": "user", "content": prompt}],
                max_tokens=2048,
                temperature=0.1,
            )
            raw = (response.get("content") or "").strip()
            if raw.startswith("```"):
                lines = raw.split("\n")
                inner = []
                in_block = False
                for line in lines:
                    if line.startswith("```"):
                        in_block = not in_block
                        continue
                    if in_block:
                        inner.append(line)
                raw = "\n".join(inner).strip()
            return json.loads(raw)
        except Exception as e:
            print(f"[Tool Analysis LLM] 调用失败: {e}")
            raise

    async def _create_or_get_tool_resource(self, tool_info: dict) -> Optional[str]:
        """创建或获取工具资源（存入 PostgreSQL tool_table）"""
        category = tool_info.get("category", "other")
        slug = tool_info.get("slug", "")
        if not slug:
            return None
        tool_id = f"tools/{category}/{slug}"
        now_ts = int(time.time())
        cursor = pg_store._get_cursor()
        try:
            cursor.execute("SELECT id FROM tool_table WHERE id = %s", (tool_id,))
            if cursor.fetchone():
                return tool_id
            cursor.execute("""
                INSERT INTO tool_table (id, name, version, introduction, tutorial, input, output,
                                        updated_time, status, knowledge, case_knowledge, process_knowledge)
                VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
            """, (
                tool_id,
                tool_info.get("name", slug),
                tool_info.get("version") or None,
                tool_info.get("description", ""),
                tool_info.get("usage", ""),
                json.dumps(tool_info.get("input", "")),
                json.dumps(tool_info.get("output", "")),
                now_ts,
                tool_info.get("status", "未接入"),
                json.dumps([]),
                json.dumps([]),
                json.dumps([]),
            ))
            pg_store.conn.commit()
            print(f"[Tool Resource] 创建新工具: {tool_id}")
            return tool_id
        finally:
            cursor.close()

    async def _update_tool_knowledge_index(self, tool_id: str, knowledge_id: str):
        """更新工具的 knowledge 关联索引（PostgreSQL tool_table）"""
        now_ts = int(time.time())
        cursor = pg_store._get_cursor()
        try:
            cursor.execute("SELECT knowledge FROM tool_table WHERE id = %s", (tool_id,))
            row = cursor.fetchone()
            if not row:
                return
            knowledge_ids = row["knowledge"] if isinstance(row["knowledge"], list) else json.loads(row["knowledge"] or "[]")
            if knowledge_id not in knowledge_ids:
                knowledge_ids.append(knowledge_id)
                cursor.execute(
                    "UPDATE tool_table SET knowledge = %s, updated_time = %s WHERE id = %s",
                    (json.dumps(knowledge_ids), now_ts, tool_id)
                )
                pg_store.conn.commit()
        finally:
            cursor.close()

    async def _analyze_tool_relation(self, knowledge: dict):
        """分析知识与工具的关联关系"""
        kid = knowledge["id"]
        now = int(time.time())
        # 乐观锁：dedup_passed → analyzing
        try:
            pg_store.update(kid, {"status": "analyzing", "updated_at": now})
        except Exception as e:
            print(f"[Tool Analysis] 锁定 {kid} 失败: {e}")
            return
        try:
            tool_analysis = await self._llm_analyze_tools(knowledge)
            has_tools = bool(tool_analysis and tool_analysis.get("has_tools"))

            existing_tags = knowledge.get("tags") or {}
            has_tool_tag = existing_tags.get("tool") is True

            # 情况1：LLM 判定无工具，但有 tool tag → 重新分析一次
            if not has_tools and has_tool_tag:
                print(f"[Tool Analysis] {kid} LLM 判定无工具但有 tool tag，重新分析")
                tool_analysis = await self._llm_analyze_tools(knowledge)
                has_tools = bool(tool_analysis and tool_analysis.get("has_tools"))
                # 重新分析后仍然不一致 → 知识模糊，rejected
                if not has_tools:
                    pg_store.update(kid, {"status": "rejected", "updated_at": now})
                    print(f"[Tool Analysis] {kid} 两次判定不一致，知识模糊，rejected")
                    return

            # 情况2：无工具且无 tool tag → 直接 approved
            if not has_tools:
                pg_store.update(kid, {"status": "approved", "updated_at": now})
                return

            # 情况3/4：有工具 → 创建资源并关联
            tool_ids = []
            for tool_info in (tool_analysis.get("tools") or []):
                tool_id = await self._create_or_get_tool_resource(tool_info)
                if tool_id:
                    tool_ids.append(tool_id)

            existing_resource_ids = knowledge.get("resource_ids") or []
            updated_resource_ids = list(set(existing_resource_ids + tool_ids))

            updates: dict = {
                "status": "approved",
                "resource_ids": updated_resource_ids,
                "updated_at": now
            }
            # 有工具但无 tool tag → 添加 tag
            if not has_tool_tag:
                updated_tags = dict(existing_tags)
                updated_tags["tool"] = True
                updates["tags"] = updated_tags
                print(f"[Tool Analysis] {kid} 添加 tool tag")

            pg_store.update(kid, updates)

            for tool_id in tool_ids:
                await self._update_tool_knowledge_index(tool_id, kid)

            print(f"[Tool Analysis] {kid} 关联了 {len(tool_ids)} 个工具")

        except Exception as e:
            print(f"[Tool Analysis] {kid} 分析失败: {e}，回退到 dedup_passed")
            try:
                pg_store.update(kid, {"status": "dedup_passed", "updated_at": int(time.time())})
            except Exception:
                pass


async def _periodic_processor():
    """每60秒检测超时条目并回滚：processing(>5min)→pending，analyzing(>10min)→dedup_passed"""
    while True:
        await asyncio.sleep(60)
        try:
            now = int(time.time())
            # 回滚超时的 processing（5分钟 → pending）
            timeout_5min = now - 300
            processing = pg_store.query('status == "processing"', limit=200)
            for item in processing:
                updated_at = item.get("updated_at", 0) or 0
                updated_at_sec = updated_at // 1000 if updated_at > 1_000_000_000_000 else updated_at
                if updated_at_sec < timeout_5min:
                    print(f"[Periodic] 回滚超时 processing → pending: {item['id']}")
                    pg_store.update(item["id"], {"status": "pending", "updated_at": int(time.time())})
            # 回滚超时的 analyzing（10分钟 → dedup_passed）
            timeout_10min = now - 600
            analyzing = pg_store.query('status == "analyzing"', limit=200)
            for item in analyzing:
                updated_at = item.get("updated_at", 0) or 0
                updated_at_sec = updated_at // 1000 if updated_at > 1_000_000_000_000 else updated_at
                if updated_at_sec < timeout_10min:
                    print(f"[Periodic] 回滚超时 analyzing → dedup_passed: {item['id']}")
                    pg_store.update(item["id"], {"status": "dedup_passed", "updated_at": int(time.time())})
        except Exception as e:
            print(f"[Periodic] 定时任务错误: {e}")


# --- App ---

@asynccontextmanager
async def lifespan(app: FastAPI):
    global pg_store, pg_resource_store, knowledge_processor

    # 初始化 PostgreSQL（knowledge + resources）
    pg_store = PostgreSQLStore()
    pg_resource_store = PostgreSQLResourceStore()

    # 初始化去重处理器 + 启动定时兜底任务
    knowledge_processor = KnowledgeProcessor()
    periodic_task = asyncio.create_task(_periodic_processor())

    yield

    # 清理
    periodic_task.cancel()
    try:
        await periodic_task
    except asyncio.CancelledError:
        pass
    pg_store.close()
    pg_resource_store.close()


app = FastAPI(title=BRAND_NAME, lifespan=lifespan)


# --- Knowledge API ---

@app.post("/api/resource", status_code=201)
def submit_resource(resource: ResourceIn):
    """提交资源（存入 PostgreSQL resources 表）"""
    try:
        # 加密敏感内容
        encrypted_secure_body = encrypt_content(resource.id, resource.secure_body)

        pg_resource_store.insert_or_update({
            'id': resource.id,
            'title': resource.title,
            'body': resource.body,
            'secure_body': encrypted_secure_body,
            'content_type': resource.content_type,
            'metadata': resource.metadata,
            'sort_order': resource.sort_order,
            'submitted_by': resource.submitted_by
        })
        return {"status": "ok", "id": resource.id}
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))


@app.get("/api/resource/{resource_id:path}", response_model=ResourceOut)
def get_resource(resource_id: str, x_org_key: Optional[str] = Header(None)):
    """获取资源详情（从 PostgreSQL）"""
    try:
        row = pg_resource_store.get_by_id(resource_id)
        if not row:
            raise HTTPException(status_code=404, detail=f"Resource not found: {resource_id}")

        # 解密敏感内容
        secure_body = decrypt_content(resource_id, row.get("secure_body", ""), x_org_key)

        # 计算导航上下文
        root_id = resource_id.split("/")[0] if "/" in resource_id else resource_id

        # TOC (根节点)
        toc = None
        if "/" in resource_id:
            toc_row = pg_resource_store.get_by_id(root_id)
            if toc_row:
                toc = ResourceNode(id=toc_row["id"], title=toc_row["title"])

        # Children (子节点)
        children_rows = pg_resource_store.list_resources(prefix=f"{resource_id}/", limit=1000)
        children = [ResourceNode(id=r["id"], title=r["title"]) for r in children_rows
                    if r["id"].count("/") == resource_id.count("/") + 1]

        # Prev/Next (同级节点)
        prev_node, next_node = pg_resource_store.get_siblings(resource_id)
        prev = ResourceNode(id=prev_node["id"], title=prev_node["title"]) if prev_node else None
        next = ResourceNode(id=next_node["id"], title=next_node["title"]) if next_node else None

        return ResourceOut(
            id=row["id"],
            title=row["title"],
            body=row["body"],
            secure_body=secure_body,
            content_type=row["content_type"],
            metadata=row.get("metadata", {}),
            toc=toc,
            children=children,
            prev=prev,
            next=next,
        )
    except HTTPException:
        raise
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))


@app.patch("/api/resource/{resource_id:path}")
def patch_resource(resource_id: str, patch: ResourcePatchIn):
    """更新resource字段（PostgreSQL）"""
    try:
        # 检查是否存在
        if not pg_resource_store.get_by_id(resource_id):
            raise HTTPException(status_code=404, detail=f"Resource not found: {resource_id}")

        # 构建更新字典
        updates = {}

        if patch.title is not None:
            updates['title'] = patch.title
        if patch.body is not None:
            updates['body'] = patch.body
        if patch.secure_body is not None:
            updates['secure_body'] = encrypt_content(resource_id, patch.secure_body)
        if patch.content_type is not None:
            updates['content_type'] = patch.content_type
        if patch.metadata is not None:
            updates['metadata'] = patch.metadata

        if not updates:
            return {"status": "ok", "message": "No fields to update"}

        pg_resource_store.update(resource_id, updates)
        return {"status": "ok", "id": resource_id}
    except HTTPException:
        raise
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))


@app.get("/api/resource")
def list_resources(
    content_type: Optional[str] = Query(None),
    limit: int = Query(100, ge=1, le=1000)
):
    """列出所有resource（PostgreSQL）"""
    try:
        results = pg_resource_store.list_resources(
            content_type=content_type,
            limit=limit
        )
        return {"results": results, "count": len(results)}
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))


@app.delete("/api/resource/{resource_id:path}")
def delete_resource(resource_id: str):
    """删除单个resource（PostgreSQL）"""
    try:
        if not pg_resource_store.get_by_id(resource_id):
            raise HTTPException(status_code=404, detail=f"Resource not found: {resource_id}")

        pg_resource_store.delete(resource_id)
        return {"status": "ok", "id": resource_id}
    except HTTPException:
        raise
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))


# --- Knowledge API ---


# ===== Knowledge API =====

async def _llm_rerank(query: str, candidates: list[dict], top_k: int) -> list[str]:
    """
    使用 LLM 对候选知识进行精排

    Args:
        query: 查询文本
        candidates: 候选知识列表
        top_k: 返回数量

    Returns:
        排序后的知识 ID 列表
    """
    if not candidates:
        return []

    # 构造 prompt
    candidates_text = "\n".join([
        f"[{i+1}] ID: {c['id']}\nTask: {c['task']}\nContent: {c['content'][:200]}..."
        for i, c in enumerate(candidates)
    ])

    prompt = f"""你是知识检索专家。根据用户查询，从候选知识中选出最相关的 {top_k} 条。

用户查询："{query}"

候选知识：
{candidates_text}

请输出最相关的 {top_k} 个知识 ID，按相关性从高到低排序，用逗号分隔。
只输出 ID，不要其他内容。"""

    try:
        response = await _dedup_llm(
            messages=[{"role": "user", "content": prompt}],
        )

        content = response.get("content", "").strip()
        # 解析 ID 列表
        selected_ids = [
            idx.strip()
            for idx in re.split(r'[,\s]+', content)
            if idx.strip().startswith(("knowledge-", "research-"))
        ]

        return selected_ids[:top_k]

    except Exception as e:
        print(f"[LLM Rerank] 失败: {e}")
        return []


@app.get("/api/knowledge/search")
async def search_knowledge_api(
    q: str = Query(..., description="查询文本"),
    top_k: int = Query(default=5, ge=1, le=20),
    min_score: int = Query(default=3, ge=1, le=5),
    types: Optional[str] = None,
    owner: Optional[str] = None
):
    """检索知识（向量召回 + LLM 精排）"""
    try:
        # 1. 生成查询向量
        query_embedding = await get_embedding(q)

        # 2. 构建过滤表达式
        filters = []
        if types:
            type_list = [t.strip() for t in types.split(',') if t.strip()]
            for t in type_list:
                filters.append(f'array_contains(types, "{t}")')
        if owner:
            owner_list = [o.strip() for o in owner.split(',') if o.strip()]
            if len(owner_list) == 1:
                filters.append(f'owner == "{owner_list[0]}"')
            else:
                # 多个owner用OR连接
                owner_filters = [f'owner == "{o}"' for o in owner_list]
                filters.append(f'({" or ".join(owner_filters)})')

        # 添加 min_score 过滤
        filters.append(f'eval["score"] >= {min_score}')

        # 只搜索 approved 和 checked 的知识
        filters.append('(status == "approved" or status == "checked")')

        filter_expr = ' and '.join(filters) if filters else None

        # 3. 向量召回（3*k 个候选）
        recall_limit = top_k * 3
        candidates = pg_store.search(
            query_embedding=query_embedding,
            filters=filter_expr,
            limit=recall_limit
        )

        if not candidates:
            return {"results": [], "count": 0, "reranked": False}

        # 转换为可序列化的格式
        serialized_candidates = [serialize_milvus_result(c) for c in candidates]

        # 4. LLM 精排
        reranked_ids = await _llm_rerank(q, serialized_candidates, top_k)

        if reranked_ids:
            # 按 LLM 排序返回
            id_to_candidate = {c["id"]: c for c in serialized_candidates}
            results = [id_to_candidate[id] for id in reranked_ids if id in id_to_candidate]
            return {"results": results, "count": len(results), "reranked": True}
        else:
            # Fallback：直接返回向量召回的 top k
            print(f"[Knowledge Search] LLM 精排失败，fallback 到向量 top-{top_k}")
            return {"results": serialized_candidates[:top_k], "count": len(serialized_candidates[:top_k]), "reranked": False}

    except Exception as e:
        print(f"[Knowledge Search] 错误: {e}")
        raise HTTPException(status_code=500, detail=str(e))


@app.post("/api/knowledge", status_code=201)
async def save_knowledge(knowledge: KnowledgeIn, background_tasks: BackgroundTasks):
    """保存新知识"""
    try:
        # 生成 ID
        timestamp = datetime.now().strftime('%Y%m%d-%H%M%S')
        random_suffix = uuid.uuid4().hex[:4]
        knowledge_id = f"knowledge-{timestamp}-{random_suffix}"

        now = int(time.time())

        # 设置默认值
        owner = knowledge.owner or f"agent:{knowledge.source.get('agent_id', 'unknown')}"

        # 准备 source
        source = {
            "name": knowledge.source.get("name", ""),
            "category": knowledge.source.get("category", ""),
            "urls": knowledge.source.get("urls", []),
            "agent_id": knowledge.source.get("agent_id", "unknown"),
            "submitted_by": knowledge.source.get("submitted_by", ""),
            "timestamp": datetime.now(timezone.utc).isoformat(),
            "message_id": knowledge.message_id
        }

        # 准备 eval
        eval_data = {
            "score": knowledge.eval.get("score", 3),
            "helpful": knowledge.eval.get("helpful", 1),
            "harmful": knowledge.eval.get("harmful", 0),
            "confidence": knowledge.eval.get("confidence", 0.5),
            "helpful_history": [],
            "harmful_history": []
        }

        # 生成向量（只基于 task，因为搜索时用户描述的是任务场景）
        embedding = await get_embedding(knowledge.task)

        # 提取 tag keys（用于高效筛选）
        tag_keys = list(knowledge.tags.keys()) if isinstance(knowledge.tags, dict) else []

        # 准备插入数据
        insert_data = {
            "id": knowledge_id,
            "embedding": embedding,
            "message_id": knowledge.message_id,
            "task": knowledge.task,
            "content": knowledge.content,
            "types": knowledge.types,
            "tags": knowledge.tags,
            "tag_keys": tag_keys,
            "scopes": knowledge.scopes,
            "owner": owner,
            "resource_ids": knowledge.resource_ids,
            "source": source,
            "eval": eval_data,
            "created_at": now,
            "updated_at": now,
            "status": "pending",
            "relationships": json.dumps([]),
        }

        print(f"[Save Knowledge] 插入数据: {json.dumps({k: v for k, v in insert_data.items() if k != 'embedding'}, ensure_ascii=False)}")

        # 插入 Milvus
        pg_store.insert(insert_data)

        # 触发后台去重处理
        background_tasks.add_task(knowledge_processor.process_pending)

        return {"status": "pending", "knowledge_id": knowledge_id, "message": "知识已入队，正在处理去重..."}

    except Exception as e:
        print(f"[Save Knowledge] 错误: {e}")
        raise HTTPException(status_code=500, detail=str(e))


@app.get("/api/knowledge")
def list_knowledge(
    page: int = Query(default=1, ge=1),
    page_size: int = Query(default=200, ge=1, le=500),
    types: Optional[str] = None,
    scopes: Optional[str] = None,
    owner: Optional[str] = None,
    tags: Optional[str] = None,
    status: Optional[str] = None
):
    """列出知识（支持后端筛选和分页）"""
    try:
        # 构建过滤表达式
        filters = []

        # types 支持多个，用 AND 连接（交集：必须同时包含所有选中的type）
        if types:
            type_list = [t.strip() for t in types.split(',') if t.strip()]
            for t in type_list:
                filters.append(f'array_contains(types, "{t}")')

        if scopes:
            filters.append(f'array_contains(scopes, "{scopes}")')

        if owner:
            owner_list = [o.strip() for o in owner.split(',') if o.strip()]
            if len(owner_list) == 1:
                filters.append(f'owner == "{owner_list[0]}"')
            else:
                # 多个owner用OR连接
                owner_filters = [f'owner == "{o}"' for o in owner_list]
                filters.append(f'({" or ".join(owner_filters)})')

        # tags 支持多个，用 AND 连接（使用 tag_keys 数组进行高效筛选）
        if tags:
            tag_list = [t.strip() for t in tags.split(',') if t.strip()]
            for t in tag_list:
                filters.append(f'array_contains(tag_keys, "{t}")')

        # 只返回指定 status 的知识（默认 approved 和 checked）
        status_list = [s.strip() for s in (status or "approved,checked").split(',') if s.strip()]
        status_conditions = ' or '.join([f'status == "{s}"' for s in status_list])
        filters.append(f'({status_conditions})')

        # 如果没有过滤条件，查询所有
        filter_expr = ' and '.join(filters) if filters else 'id != ""'

        # 查询 Milvus（先获取所有符合条件的数据）
        # Milvus 的 limit 是总数限制，我们需要获取足够多的数据来支持分页
        max_limit = 10000  # 设置一个合理的上限
        results = pg_store.query(filter_expr, limit=max_limit)

        # 转换为可序列化的格式
        serialized_results = [serialize_milvus_result(r) for r in results]

        # 按 created_at 降序排序（最新的在前）
        serialized_results.sort(key=lambda x: x.get('created_at', 0), reverse=True)

        # 计算分页
        total = len(serialized_results)
        total_pages = (total + page_size - 1) // page_size  # 向上取整
        start_idx = (page - 1) * page_size
        end_idx = start_idx + page_size
        page_results = serialized_results[start_idx:end_idx]

        return {
            "results": page_results,
            "pagination": {
                "page": page,
                "page_size": page_size,
                "total": total,
                "total_pages": total_pages
            }
        }

    except Exception as e:
        print(f"[List Knowledge] 错误: {e}")
        raise HTTPException(status_code=500, detail=str(e))


@app.get("/api/knowledge/meta/tags")
def get_all_tags():
    """获取所有已有的 tags"""
    try:
        # 查询所有知识
        results = pg_store.query('id != ""', limit=10000)

        all_tags = set()
        for item in results:
            # 转换为标准字典
            serialized_item = serialize_milvus_result(item)
            tags_dict = serialized_item.get("tags", {})
            if isinstance(tags_dict, dict):
                for key in tags_dict.keys():
                    all_tags.add(key)

        return {"tags": sorted(list(all_tags))}

    except Exception as e:
        print(f"[Get Tags] 错误: {e}")
        raise HTTPException(status_code=500, detail=str(e))


@app.get("/api/knowledge/pending")
def get_pending_knowledge(limit: int = Query(default=50, ge=1, le=200)):
    """查询待处理队列（pending + processing + dedup_passed + analyzing）"""
    try:
        pending = pg_store.query(
            'status == "pending" or status == "processing" or status == "dedup_passed" or status == "analyzing"',
            limit=limit
        )
        serialized = [serialize_milvus_result(r) for r in pending]
        return {"results": serialized, "count": len(serialized)}
    except Exception as e:
        print(f"[Pending] 错误: {e}")
        raise HTTPException(status_code=500, detail=str(e))


@app.post("/api/knowledge/process")
async def trigger_process(force: bool = Query(default=False)):
    """手动触发去重处理。force=true 时先回滚所有 processing → pending，analyzing → dedup_passed"""
    try:
        if force:
            processing = pg_store.query('status == "processing"', limit=200)
            for item in processing:
                pg_store.update(item["id"], {"status": "pending", "updated_at": int(time.time())})
            print(f"[Manual Process] 回滚 {len(processing)} 条 processing → pending")
            analyzing = pg_store.query('status == "analyzing"', limit=200)
            for item in analyzing:
                pg_store.update(item["id"], {"status": "dedup_passed", "updated_at": int(time.time())})
            print(f"[Manual Process] 回滚 {len(analyzing)} 条 analyzing → dedup_passed")
        asyncio.create_task(knowledge_processor.process_pending())
        return {"status": "ok", "message": "处理任务已触发"}
    except Exception as e:
        print(f"[Manual Process] 错误: {e}")
        raise HTTPException(status_code=500, detail=str(e))


@app.post("/api/knowledge/migrate")
async def migrate_knowledge_schema():
    """手动触发 schema 迁移（PostgreSQL不需要此功能）"""
    return {"status": "ok", "message": "PostgreSQL不需要schema迁移"}


@app.get("/api/knowledge/status/{knowledge_id}")
def get_knowledge_status(knowledge_id: str):
    """查询单条知识的处理状态和关系"""
    try:
        result = pg_store.get_by_id(knowledge_id)
        if not result:
            raise HTTPException(status_code=404, detail=f"Knowledge not found: {knowledge_id}")
        serialized = serialize_milvus_result(result)
        return {
            "id": knowledge_id,
            "status": serialized.get("status", "approved"),
            "relationships": serialized.get("relationships", []),
            "created_at": serialized.get("created_at"),
            "updated_at": serialized.get("updated_at"),
        }
    except HTTPException:
        raise
    except Exception as e:
        print(f"[Knowledge Status] 错误: {e}")
        raise HTTPException(status_code=500, detail=str(e))


@app.get("/api/knowledge/{knowledge_id}")
def get_knowledge(knowledge_id: str):
    """获取单条知识"""
    try:
        result = pg_store.get_by_id(knowledge_id)
        if not result:
            raise HTTPException(status_code=404, detail=f"Knowledge not found: {knowledge_id}")

        return serialize_milvus_result(result)

    except HTTPException:
        raise
    except Exception as e:
        print(f"[Get Knowledge] 错误: {e}")
        raise HTTPException(status_code=500, detail=str(e))


async def _evolve_knowledge_with_llm(old_content: str, feedback: str) -> str:
    """使用 LLM 进行知识进化重写"""
    prompt = f"""你是一个 AI Agent 知识库管理员。请根据反馈建议，对现有的知识内容进行重写进化。

【原知识内容】:
{old_content}

【实战反馈建议】:
{feedback}

【重写要求】:
1. 融合知识：将反馈中的避坑指南、新参数或修正后的选择逻辑融入原知识，使其更具通用性和准确性。
2. 保持结构：如果原内容有特定格式（如 Markdown、代码示例等），请保持该格式。
3. 语言：简洁直接，使用中文。
4. 禁止：严禁输出任何开场白、解释语或额外的 Markdown 标题，直接返回重写后的正文。
"""
    try:
        response = await _dedup_llm(
            messages=[{"role": "user", "content": prompt}],
        )
        evolved = response.get("content", "").strip()
        if len(evolved) < 5:
            raise ValueError("LLM output too short")
        return evolved
    except Exception as e:
        print(f"知识进化失败，采用追加模式回退: {e}")
        return f"{old_content}\n\n---\n[Update {datetime.now().strftime('%Y-%m-%d')}]: {feedback}"


@app.put("/api/knowledge/{knowledge_id}")
async def update_knowledge(knowledge_id: str, update: KnowledgeUpdateIn):
    """更新知识评估，支持知识进化"""
    try:
        # 获取现有知识
        existing = pg_store.get_by_id(knowledge_id)
        if not existing:
            raise HTTPException(status_code=404, detail=f"Knowledge not found: {knowledge_id}")

        eval_data = existing.get("eval", {})

        # 更新评分
        if update.update_score is not None:
            eval_data["score"] = update.update_score

        # 添加有效案例
        if update.add_helpful_case:
            eval_data["helpful"] = eval_data.get("helpful", 0) + 1
            if "helpful_history" not in eval_data:
                eval_data["helpful_history"] = []
            eval_data["helpful_history"].append(update.add_helpful_case)

        # 添加有害案例
        if update.add_harmful_case:
            eval_data["harmful"] = eval_data.get("harmful", 0) + 1
            if "harmful_history" not in eval_data:
                eval_data["harmful_history"] = []
            eval_data["harmful_history"].append(update.add_harmful_case)

        # 知识进化
        content = existing["content"]
        need_reembed = False

        if update.evolve_feedback:
            content = await _evolve_knowledge_with_llm(content, update.evolve_feedback)
            eval_data["helpful"] = eval_data.get("helpful", 0) + 1
            need_reembed = True

        # 准备更新数据
        updates = {
            "content": content,
            "eval": eval_data,
        }

        # 如果内容变化，重新生成向量
        if need_reembed:
            embedding = await get_embedding(existing['task'])
            updates["embedding"] = embedding

        # 更新 Milvus
        pg_store.update(knowledge_id, updates)

        return {"status": "ok", "knowledge_id": knowledge_id}

    except HTTPException:
        raise
    except Exception as e:
        print(f"[Update Knowledge] 错误: {e}")
        raise HTTPException(status_code=500, detail=str(e))


@app.patch("/api/knowledge/{knowledge_id}")
async def patch_knowledge(knowledge_id: str, patch: KnowledgePatchIn):
    """直接编辑知识字段"""
    try:
        # 获取现有知识
        existing = pg_store.get_by_id(knowledge_id)
        if not existing:
            raise HTTPException(status_code=404, detail=f"Knowledge not found: {knowledge_id}")

        updates = {}
        need_reembed = False

        if patch.task is not None:
            updates["task"] = patch.task
            need_reembed = True

        if patch.content is not None:
            updates["content"] = patch.content
            # content 变化不需要重新生成 embedding（只基于 task）

        if patch.types is not None:
            updates["types"] = patch.types

        if patch.tags is not None:
            updates["tags"] = patch.tags
            # 同时更新 tag_keys
            updates["tag_keys"] = list(patch.tags.keys()) if isinstance(patch.tags, dict) else []

        if patch.scopes is not None:
            updates["scopes"] = patch.scopes

        if patch.owner is not None:
            updates["owner"] = patch.owner

        if not updates:
            return {"status": "ok", "knowledge_id": knowledge_id}

        # 如果 task 变化，重新生成向量
        if need_reembed:
            task = updates.get("task", existing["task"])
            embedding = await get_embedding(task)
            updates["embedding"] = embedding

        # 更新 Milvus
        pg_store.update(knowledge_id, updates)

        return {"status": "ok", "knowledge_id": knowledge_id}

    except HTTPException:
        raise
    except Exception as e:
        print(f"[Patch Knowledge] 错误: {e}")
        raise HTTPException(status_code=500, detail=str(e))


@app.delete("/api/knowledge/{knowledge_id}")
def delete_knowledge(knowledge_id: str):
    """删除单条知识"""
    try:
        # 检查知识是否存在
        existing = pg_store.get_by_id(knowledge_id)
        if not existing:
            raise HTTPException(status_code=404, detail=f"Knowledge not found: {knowledge_id}")

        # 从 PostgreSQL 删除
        pg_store.delete(knowledge_id)
        print(f"[Delete Knowledge] 已删除知识: {knowledge_id}")

        return {"status": "ok", "knowledge_id": knowledge_id}

    except HTTPException:
        raise
    except Exception as e:
        print(f"[Delete Knowledge] 错误: {e}")
        raise HTTPException(status_code=500, detail=str(e))


@app.post("/api/knowledge/batch_delete")
def batch_delete_knowledge(knowledge_ids: List[str] = Body(...)):
    """批量删除知识"""
    try:
        if not knowledge_ids:
            raise HTTPException(status_code=400, detail="knowledge_ids cannot be empty")

        # 批量删除
        cursor = pg_store._get_cursor()
        try:
            cursor.execute(
                "DELETE FROM knowledge WHERE id = ANY(%s)",
                (knowledge_ids,)
            )
            pg_store.conn.commit()
            deleted_count = cursor.rowcount
            print(f"[Batch Delete] 已删除 {deleted_count} 条知识")
            return {"status": "ok", "deleted_count": deleted_count}
        finally:
            cursor.close()

    except HTTPException:
        raise
    except Exception as e:
        print(f"[Batch Delete] 错误: {e}")
        raise HTTPException(status_code=500, detail=str(e))


@app.post("/api/knowledge/batch_verify")
async def batch_verify_knowledge(batch: KnowledgeBatchVerifyIn):
    """批量验证通过（approved → checked）"""
    if not batch.knowledge_ids:
        return {"status": "ok", "updated": 0}

    try:
        now_iso = datetime.now(timezone.utc).isoformat()
        updated_count = 0

        for kid in batch.knowledge_ids:
            existing = pg_store.get_by_id(kid)
            if not existing:
                continue

            eval_data = existing.get("eval") or {}
            eval_data["verification"] = {
                "status": "checked",
                "verified_by": batch.verified_by,
                "verified_at": now_iso,
                "note": None,
                "issue_type": None,
                "issue_action": None,
            }
            pg_store.update(kid, {"eval": eval_data, "status": "checked", "updated_at": int(time.time())})
            updated_count += 1

        return {"status": "ok", "updated": updated_count}

    except Exception as e:
        print(f"[Batch Verify] 错误: {e}")
        raise HTTPException(status_code=500, detail=str(e))


@app.post("/api/knowledge/{knowledge_id}/verify")
async def verify_knowledge(knowledge_id: str, verify: KnowledgeVerifyIn):
    """知识验证：approve 切换 approved↔checked，reject 设为 rejected"""
    try:
        existing = pg_store.get_by_id(knowledge_id)
        if not existing:
            raise HTTPException(status_code=404, detail=f"Knowledge not found: {knowledge_id}")

        current_status = existing.get("status", "approved")

        if verify.action == "approve":
            # checked → approved（取消验证），其他 → checked
            new_status = "approved" if current_status == "checked" else "checked"
            pg_store.update(knowledge_id, {
                "status": new_status,
                "updated_at": int(time.time())
            })
            return {"status": "ok", "new_status": new_status,
                    "message": "已取消验证" if new_status == "approved" else "验证通过"}

        elif verify.action == "reject":
            pg_store.update(knowledge_id, {
                "status": "rejected",
                "updated_at": int(time.time())
            })
            return {"status": "ok", "new_status": "rejected", "message": "已拒绝"}

        else:
            raise HTTPException(status_code=400, detail=f"Unknown action: {verify.action}")

    except HTTPException:
        raise
    except Exception as e:
        print(f"[Verify Knowledge] 错误: {e}")
        raise HTTPException(status_code=500, detail=str(e))


@app.post("/api/knowledge/batch_update")
async def batch_update_knowledge(batch: KnowledgeBatchUpdateIn):
    """批量反馈知识有效性"""
    if not batch.feedback_list:
        return {"status": "ok", "updated": 0}

    try:
        # 先处理无需进化的，收集需要进化的
        evolution_tasks = []   # [(knowledge_id, old_content, feedback, eval_data)]
        simple_updates = []    # [(knowledge_id, is_effective, eval_data)]

        for item in batch.feedback_list:
            knowledge_id = item.get("knowledge_id")
            is_effective = item.get("is_effective")
            feedback = item.get("feedback", "")

            if not knowledge_id:
                continue

            existing = pg_store.get_by_id(knowledge_id)
            if not existing:
                continue

            eval_data = existing.get("eval", {})

            if is_effective and feedback:
                evolution_tasks.append((knowledge_id, existing["content"], feedback, eval_data, existing["task"]))
            else:
                simple_updates.append((knowledge_id, is_effective, eval_data))

        # 执行简单更新
        for knowledge_id, is_effective, eval_data in simple_updates:
            if is_effective:
                eval_data["helpful"] = eval_data.get("helpful", 0) + 1
            else:
                eval_data["harmful"] = eval_data.get("harmful", 0) + 1

            pg_store.update(knowledge_id, {"eval": eval_data})

        # 并发执行知识进化
        if evolution_tasks:
            print(f"🧬 并发处理 {len(evolution_tasks)} 条知识进化...")
            evolved_results = await asyncio.gather(
                *[_evolve_knowledge_with_llm(old, fb) for _, old, fb, _, _ in evolution_tasks]
            )

            for (knowledge_id, _, _, eval_data, task), evolved_content in zip(evolution_tasks, evolved_results):
                eval_data["helpful"] = eval_data.get("helpful", 0) + 1

                # 重新生成向量（只基于 task）
                embedding = await get_embedding(task)

                pg_store.update(knowledge_id, {
                    "content": evolved_content,
                    "eval": eval_data,
                    "embedding": embedding
                })

        return {"status": "ok", "updated": len(simple_updates) + len(evolution_tasks)}

    except Exception as e:
        print(f"[Batch Update] 错误: {e}")
        raise HTTPException(status_code=500, detail=str(e))


@app.post("/api/knowledge/slim")
async def slim_knowledge(model: str = "google/gemini-2.5-flash-lite"):
    """知识库瘦身：合并语义相似知识"""
    try:
        # 获取所有知识
        all_knowledge = pg_store.query('id != ""', limit=10000)
        # 转换为可序列化的格式
        all_knowledge = [serialize_milvus_result(item) for item in all_knowledge]

        if len(all_knowledge) < 2:
            return {"status": "ok", "message": f"知识库仅有 {len(all_knowledge)} 条，无需瘦身"}

        # 构造发给大模型的内容
        entries_text = ""
        for item in all_knowledge:
            eval_data = item.get("eval", {})
            types = item.get("types", [])
            entries_text += f"[ID: {item['id']}] [Types: {','.join(types)}] "
            entries_text += f"[Helpful: {eval_data.get('helpful', 0)}, Harmful: {eval_data.get('harmful', 0)}] [Score: {eval_data.get('score', 3)}]\n"
            entries_text += f"Task: {item['task']}\n"
            entries_text += f"Content: {item['content'][:200]}...\n\n"

        prompt = f"""你是一个 AI Agent 知识库管理员。以下是当前知识库的全部条目，请执行瘦身操作：

【任务】:
1. 识别语义高度相似或重复的知识，将它们合并为一条更精炼、更通用的知识。
2. 合并时保留 helpful 最高的那条的 ID（helpful 取各条之和）。
3. 对于独立的、无重复的知识，保持原样不动。

【当前知识库】:
{entries_text}

【输出格式要求】:
严格按以下格式输出每条知识，条目之间用 === 分隔：
ID: <保留的id>
TYPES: <逗号分隔的type列表>
HELPFUL: <合并后的helpful计数>
HARMFUL: <合并后的harmful计数>
SCORE: <评分>
TASK: <任务描述>
CONTENT: <合并后的知识内容>
===

最后输出合并报告：
REPORT: 原有 X 条，合并后 Y 条，精简了 Z 条。

禁止输出任何开场白或解释。"""

        print(f"\n[知识瘦身] 正在调用 {model} 分析 {len(all_knowledge)} 条知识...")
        slim_llm = create_openrouter_llm_call(model=model)
        response = await slim_llm(
            messages=[{"role": "user", "content": prompt}],
        )
        content = response.get("content", "").strip()
        if not content:
            raise HTTPException(status_code=500, detail="LLM 返回为空")

        # 解析大模型输出
        report_line = ""
        new_entries = []
        blocks = [b.strip() for b in content.split("===") if b.strip()]

        for block in blocks:
            if block.startswith("REPORT:"):
                report_line = block
                continue

            lines = block.split("\n")
            kid, types, helpful, harmful, score, task, content_lines = None, [], 0, 0, 3, "", []
            current_field = None

            for line in lines:
                if line.startswith("ID:"):
                    kid = line[3:].strip()
                    current_field = None
                elif line.startswith("TYPES:"):
                    types_str = line[6:].strip()
                    types = [t.strip() for t in types_str.split(",") if t.strip()]
                    current_field = None
                elif line.startswith("HELPFUL:"):
                    try:
                        helpful = int(line[8:].strip())
                    except Exception:
                        helpful = 0
                    current_field = None
                elif line.startswith("HARMFUL:"):
                    try:
                        harmful = int(line[8:].strip())
                    except Exception:
                        harmful = 0
                    current_field = None
                elif line.startswith("SCORE:"):
                    try:
                        score = int(line[6:].strip())
                    except Exception:
                        score = 3
                    current_field = None
                elif line.startswith("TASK:"):
                    task = line[5:].strip()
                    current_field = "task"
                elif line.startswith("CONTENT:"):
                    content_lines.append(line[8:].strip())
                    current_field = "content"
                elif current_field == "task":
                    task += "\n" + line
                elif current_field == "content":
                    content_lines.append(line)

            if kid and content_lines:
                new_entries.append({
                    "id": kid,
                    "types": types if types else ["strategy"],
                    "helpful": helpful,
                    "harmful": harmful,
                    "score": score,
                    "task": task.strip(),
                    "content": "\n".join(content_lines).strip()
                })

        if not new_entries:
            raise HTTPException(status_code=500, detail="解析大模型输出失败")

        # 生成向量并重建知识库
        print(f"[知识瘦身] 正在为 {len(new_entries)} 条知识生成向量...")

        # 批量生成向量（只基于 task）
        texts = [e['task'] for e in new_entries]
        embeddings = await get_embeddings_batch(texts)

        # 清空并重建（PostgreSQL使用TRUNCATE）
        cursor = pg_store._get_cursor()
        try:
            cursor.execute("TRUNCATE TABLE knowledge")
            pg_store.conn.commit()
        finally:
            cursor.close()

        knowledge_list = []
        for e, embedding in zip(new_entries, embeddings):
            eval_data = {
                "score": e["score"],
                "helpful": e["helpful"],
                "harmful": e["harmful"],
                "confidence": 0.9,
                "helpful_history": [],
                "harmful_history": []
            }
            source = {
                "name": "slim",
                "category": "exp",
                "urls": [],
                "agent_id": "slim",
                "submitted_by": "system",
                "timestamp": datetime.now(timezone.utc).isoformat()
            }
            knowledge_list.append({
                "id": e["id"],
                "embedding": embedding,
                "message_id": "",
                "task": e["task"],
                "content": e["content"],
                "types": e["types"],
                "tags": {},
                "tag_keys": [],
                "scopes": ["org:cybertogether"],
                "owner": "agent:slim",
                "resource_ids": [],
                "source": source,
                "eval": eval_data,
                "created_at": now,
                "updated_at": now,
                "status": "approved",
                "relationships": json.dumps([])
            })

        pg_store.insert_batch(knowledge_list)

        result_msg = f"瘦身完成：{len(all_knowledge)} → {len(new_entries)} 条知识"
        if report_line:
            result_msg += f"\n{report_line}"
        print(f"[知识瘦身] {result_msg}")

        return {"status": "ok", "before": len(all_knowledge), "after": len(new_entries), "report": report_line}

    except HTTPException:
        raise
    except Exception as e:
        print(f"[Slim Knowledge] 错误: {e}")
        raise HTTPException(status_code=500, detail=str(e))


@app.post("/api/extract")
async def extract_knowledge_from_messages(extract_req: MessageExtractIn, background_tasks: BackgroundTasks):
    """从消息历史中提取知识（LLM 分析）"""
    if not extract_req.submitted_by:
        raise HTTPException(status_code=400, detail="submitted_by is required")

    messages = extract_req.messages
    if not messages or len(messages) == 0:
        return {"status": "ok", "extracted_count": 0, "knowledge_ids": []}

    # 构造消息历史文本
    messages_text = ""
    for msg in messages:
        role = msg.get("role", "unknown")
        content = msg.get("content", "")
        messages_text += f"[{role}]: {content}\n\n"

    # LLM 提取知识
    prompt = f"""你是一个知识提取专家。请从以下 Agent 对话历史中提取有价值的知识。

【对话历史】:
{messages_text}

【提取要求】:
1. 识别对话中的关键知识点（工具使用经验、问题解决方案、最佳实践、踩坑经验等）
2. 每条知识必须包含：
   - task: 任务场景描述（在什么情况下，要完成什么目标）
   - content: 核心知识内容（具体可操作的方法、注意事项）
   - types: 知识类型（从 strategy/tool/user_profile/usecase/definition/plan 中选择）
   - score: 评分 1-5（根据知识的价值和可操作性）
3. 只提取有实际价值的知识，不要提取泛泛而谈的内容，一次就成功或比较简单的经验就不要记录了。
4. 如果没有值得提取的知识，返回空列表

【输出格式】:
严格按以下 JSON 格式输出，每条知识之间用逗号分隔：
[
  {{
    "task": "任务场景描述",
    "content": "核心知识内容",
    "types": ["strategy"],
    "score": 4
  }},
  {{
    "task": "另一个任务场景",
    "content": "另一个知识内容",
    "types": ["tool"],
    "score": 5
  }}
]

如果没有知识，输出: []

**注意**：只记录经过多次尝试、或经过用户指导才成功的知识，一次就成功或比较简单的经验就不要记录了。

禁止输出任何解释或额外文本，只输出 JSON 数组。"""

    try:
        print(f"\n[Extract] 正在从 {len(messages)} 条消息中提取知识...")

        response = await _dedup_llm(
            messages=[{"role": "user", "content": prompt}],
        )

        content = response.get("content", "").strip()

        # 尝试解析 JSON
        # 移除可能的 markdown 代码块标记
        if content.startswith("```json"):
            content = content[7:]
        if content.startswith("```"):
            content = content[3:]
        if content.endswith("```"):
            content = content[:-3]
        content = content.strip()

        extracted_knowledge = json.loads(content)

        if not isinstance(extracted_knowledge, list):
            raise ValueError("LLM output is not a list")

        if not extracted_knowledge:
            return {"status": "ok", "extracted_count": 0, "knowledge_ids": []}

        # 批量生成向量（只基于 task）
        texts = [item.get('task', '') for item in extracted_knowledge]
        embeddings = await get_embeddings_batch(texts)

        # 保存提取的知识
        knowledge_ids = []
        now = int(time.time())
        knowledge_list = []

        for item, embedding in zip(extracted_knowledge, embeddings):
            task = item.get("task", "")
            knowledge_content = item.get("content", "")
            types = item.get("types", ["strategy"])
            score = item.get("score", 3)

            if not task or not knowledge_content:
                continue

            # 生成 ID
            timestamp = datetime.now().strftime('%Y%m%d-%H%M%S')
            random_suffix = uuid.uuid4().hex[:4]
            knowledge_id = f"knowledge-{timestamp}-{random_suffix}"

            # 准备数据
            source = {
                "name": "message_extraction",
                "category": "exp",
                "urls": [],
                "agent_id": extract_req.agent_id,
                "submitted_by": extract_req.submitted_by,
                "timestamp": datetime.now(timezone.utc).isoformat(),
                "session_key": extract_req.session_key
            }

            eval_data = {
                "score": score,
                "helpful": 1,
                "harmful": 0,
                "confidence": 0.7,
                "helpful_history": [],
                "harmful_history": []
            }

            knowledge_list.append({
                "id": knowledge_id,
                "embedding": embedding,
                "message_id": "",
                "task": task,
                "content": knowledge_content,
                "types": types,
                "tags": {},
                "tag_keys": [],
                "scopes": ["org:cybertogether"],
                "owner": extract_req.submitted_by,
                "resource_ids": [],
                "source": source,
                "eval": eval_data,
                "created_at": now,
                "updated_at": now,
                "status": "pending",
                "relationships": json.dumps([]),
            })
            knowledge_ids.append(knowledge_id)

        # 批量插入
        if knowledge_list:
            pg_store.insert_batch(knowledge_list)
            background_tasks.add_task(knowledge_processor.process_pending)

        print(f"[Extract] 成功提取并保存 {len(knowledge_ids)} 条知识")

        return {
            "status": "ok",
            "extracted_count": len(knowledge_ids),
            "knowledge_ids": knowledge_ids
        }

    except json.JSONDecodeError as e:
        print(f"[Extract] JSON 解析失败: {e}")
        print(f"[Extract] LLM 输出: {content[:500]}")
        return {"status": "error", "error": "Failed to parse LLM output", "extracted_count": 0}
    except Exception as e:
        print(f"[Extract] 提取失败: {e}")
        return {"status": "error", "error": str(e), "extracted_count": 0}


@app.get("/", response_class=HTMLResponse)
def frontend():
    """KnowHub 管理前端"""
    return """<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>KnowHub 管理</title>
    <script src="https://cdn.tailwindcss.com"></script>
    <script src="https://cdn.jsdelivr.net/npm/marked/marked.min.js"></script>
</head>
<body class="bg-gray-50">
    <div class="container mx-auto px-4 py-8 max-w-7xl">
        <div class="flex justify-between items-center mb-8">
            <h1 class="text-3xl font-bold text-gray-800">KnowHub 全局知识库</h1>
            <div class="flex gap-3">
                <button onclick="toggleSelectAll()" id="selectAllBtn" class="bg-gray-500 hover:bg-gray-600 text-white px-4 py-2 rounded-lg">
                    全选
                </button>
                <button onclick="batchDelete()" id="batchDeleteBtn" class="bg-red-600 hover:bg-red-700 text-white px-4 py-2 rounded-lg disabled:opacity-50 disabled:cursor-not-allowed" disabled>
                    删除选中 (<span id="selectedCount">0</span>)
                </button>
                <button onclick="batchVerify()" id="batchVerifyBtn" class="bg-green-600 hover:bg-green-700 text-white px-4 py-2 rounded-lg disabled:opacity-50 disabled:cursor-not-allowed" disabled>
                    ✓ 批量验证通过 (<span id="verifyCount">0</span>)
                </button>
                <button onclick="openToolTableModal()" class="bg-indigo-600 hover:bg-indigo-700 text-white px-4 py-2 rounded-lg">
                    🔧 工具表
                </button>
                <button onclick="openAddModal()" class="bg-blue-600 hover:bg-blue-700 text-white px-6 py-2 rounded-lg">
                    + 新增知识
                </button>
            </div>
        </div>

        <!-- 搜索栏 -->
        <div class="bg-white rounded-lg shadow p-6 mb-6">
            <div class="flex gap-4">
                <input type="text" id="searchInput" placeholder="输入任务描述进行语义搜索..."
                       class="flex-1 border rounded px-4 py-2 focus:outline-none focus:ring-2 focus:ring-blue-500"
                       onkeypress="if(event.key==='Enter') performSearch()">
                <button onclick="performSearch()" class="bg-blue-600 hover:bg-blue-700 text-white px-6 py-2 rounded">
                    搜索
                </button>
                <button onclick="clearSearch()" class="bg-gray-500 hover:bg-gray-600 text-white px-6 py-2 rounded">
                    清除
                </button>
            </div>
            <div id="searchStatus" class="mt-2 text-sm text-gray-600 hidden"></div>
        </div>

        <!-- 筛选栏 -->
        <div class="bg-white rounded-lg shadow p-6 mb-6">
            <div class="grid grid-cols-1 md:grid-cols-5 gap-4">
                <div>
                    <label class="block text-sm font-medium text-gray-700 mb-2">类型 (Types)</label>
                    <div class="space-y-2">
                        <label class="flex items-center"><input type="checkbox" value="strategy" class="mr-2 type-filter"> Strategy</label>
                        <label class="flex items-center"><input type="checkbox" value="tool" class="mr-2 type-filter"> Tool</label>
                        <label class="flex items-center"><input type="checkbox" value="user_profile" class="mr-2 type-filter"> User Profile</label>
                        <label class="flex items-center"><input type="checkbox" value="usecase" class="mr-2 type-filter"> Usecase</label>
                        <label class="flex items-center"><input type="checkbox" value="definition" class="mr-2 type-filter"> Definition</label>
                        <label class="flex items-center"><input type="checkbox" value="plan" class="mr-2 type-filter"> Plan</label>
                    </div>
                </div>
                <div>
                    <label class="block text-sm font-medium text-gray-700 mb-2">Tags</label>
                    <div id="tagsFilterContainer" class="space-y-2 max-h-40 overflow-y-auto">
                        <p class="text-sm text-gray-500">加载中...</p>
                    </div>
                </div>
                <div>
                    <label class="block text-sm font-medium text-gray-700 mb-2">Owner</label>
                    <input type="text" id="ownerFilter" placeholder="输入 owner" class="w-full border rounded px-3 py-2">
                </div>
                <div>
                    <label class="block text-sm font-medium text-gray-700 mb-2">Scopes</label>
                    <input type="text" id="scopesFilter" placeholder="输入 scope" class="w-full border rounded px-3 py-2">
                </div>
                <div>
                    <label class="block text-sm font-medium text-gray-700 mb-2">Status</label>
                    <div class="space-y-2">
                        <label class="flex items-center"><input type="checkbox" value="approved" class="mr-2 status-filter" checked> Approved</label>
                        <label class="flex items-center"><input type="checkbox" value="checked" class="mr-2 status-filter" checked> Checked</label>
                        <label class="flex items-center"><input type="checkbox" value="rejected" class="mr-2 status-filter"> Rejected</label>
                        <label class="flex items-center"><input type="checkbox" value="pending" class="mr-2 status-filter"> Pending</label>
                    </div>
                </div>
            </div>
            <button onclick="applyFilters()" class="mt-4 bg-gray-600 hover:bg-gray-700 text-white px-4 py-2 rounded">
                应用筛选
            </button>
        </div>

        <!-- 知识列表 -->
        <div id="knowledgeList" class="space-y-4"></div>

        <!-- 分页控件 -->
        <div id="pagination" class="flex justify-center items-center gap-4 mt-6 hidden">
            <button onclick="goToPage(currentPage - 1)" id="prevBtn" class="bg-gray-600 hover:bg-gray-700 text-white px-4 py-2 rounded disabled:opacity-50 disabled:cursor-not-allowed">
                上一页
            </button>
            <span id="pageInfo" class="text-gray-700"></span>
            <button onclick="goToPage(currentPage + 1)" id="nextBtn" class="bg-gray-600 hover:bg-gray-700 text-white px-4 py-2 rounded disabled:opacity-50 disabled:cursor-not-allowed">
                下一页
            </button>
        </div>
    </div>

    <!-- 新增/编辑 Modal -->
    <div id="modal" class="hidden fixed inset-0 bg-black bg-opacity-50 flex items-center justify-center p-4">
        <div class="bg-white rounded-lg max-w-2xl w-full max-h-[90vh] overflow-y-auto p-6">
            <h2 id="modalTitle" class="text-2xl font-bold mb-4">新增知识</h2>
            <form id="knowledgeForm" class="space-y-4">
                <input type="hidden" id="editId">
                <div>
                    <label class="block text-sm font-medium mb-1">Task *</label>
                    <input type="text" id="taskInput" required class="w-full border rounded px-3 py-2">
                </div>
                <div>
                    <label class="block text-sm font-medium mb-1">Content *</label>
                    <textarea id="contentInput" required rows="6" class="w-full border rounded px-3 py-2"></textarea>
                </div>
                <div>
                    <label class="block text-sm font-medium mb-1">Types (多选)</label>
                    <div class="space-y-1">
                        <label class="flex items-center"><input type="checkbox" value="strategy" class="mr-2 type-checkbox"> Strategy</label>
                        <label class="flex items-center"><input type="checkbox" value="tool" class="mr-2 type-checkbox"> Tool</label>
                        <label class="flex items-center"><input type="checkbox" value="user_profile" class="mr-2 type-checkbox"> User Profile</label>
                        <label class="flex items-center"><input type="checkbox" value="usecase" class="mr-2 type-checkbox"> Usecase</label>
                        <label class="flex items-center"><input type="checkbox" value="definition" class="mr-2 type-checkbox"> Definition</label>
                        <label class="flex items-center"><input type="checkbox" value="plan" class="mr-2 type-checkbox"> Plan</label>
                    </div>
                </div>
                <div>
                    <label class="block text-sm font-medium mb-1">Tags (JSON)</label>
                    <textarea id="tagsInput" rows="2" placeholder='{"key": "value"}' class="w-full border rounded px-3 py-2"></textarea>
                </div>
                <div>
                    <label class="block text-sm font-medium mb-1">Scopes (逗号分隔)</label>
                    <input type="text" id="scopesInput" placeholder="org:cybertogether" class="w-full border rounded px-3 py-2">
                </div>
                <div>
                    <label class="block text-sm font-medium mb-1">Owner</label>
                    <input type="text" id="ownerInput" class="w-full border rounded px-3 py-2">
                </div>
                <div id="relationshipsSection" class="hidden">
                    <label class="block text-sm font-medium text-gray-700 mb-2">关联知识</label>
                    <div id="relationshipsList" class="space-y-1 text-sm bg-gray-50 rounded p-3"></div>
                </div>
                <div class="flex gap-2 pt-4">
                    <button type="submit" class="bg-blue-600 hover:bg-blue-700 text-white px-6 py-2 rounded">保存</button>
                    <button type="button" onclick="closeModal()" class="bg-gray-300 hover:bg-gray-400 px-6 py-2 rounded">取消</button>
                </div>
            </form>
        </div>
    </div>

    <!-- 工具表 Modal -->
    <div id="toolTableModal" class="hidden fixed inset-0 bg-black bg-opacity-50 flex items-center justify-center p-4 z-50">
        <div class="bg-white rounded-xl shadow-xl w-full max-w-5xl max-h-[90vh] flex flex-col">
            <div class="flex justify-between items-center p-6 border-b">
                <h2 class="text-2xl font-bold">🔧 工具表</h2>
                <button onclick="closeToolTableModal()" class="text-gray-400 hover:text-gray-600 text-2xl">✕</button>
            </div>
            <div id="toolCategoryTabs" class="flex gap-2 px-6 pt-4 flex-wrap border-b pb-4"></div>
            <div class="flex flex-1 overflow-hidden">
                <div id="toolList" class="w-[250px] border-r overflow-y-auto p-4 space-y-2 bg-gray-50 flex-shrink-0">
                    <p class="text-sm text-gray-500 text-center mt-4">加载中...</p>
                </div>
                <div id="toolDetail" class="flex-1 overflow-y-auto p-6 bg-white">
                    <div class="flex h-full items-center justify-center text-gray-400">
                        ← 请在左侧选择要查看的工具
                    </div>
                </div>
            </div>
        </div>
    </div>

    <!-- 知识详情弹窗（只读）-->
    <div id="knowledgeDetailModal" class="hidden fixed inset-0 bg-black bg-opacity-60 flex items-center justify-center p-4 z-[60]">
        <div class="bg-white rounded-xl shadow-xl w-full max-w-2xl max-h-[85vh] flex flex-col">
            <div class="flex justify-between items-center p-6 border-b">
                <h2 class="text-xl font-bold text-gray-800">知识详情</h2>
                <button onclick="closeKnowledgeDetailModal()" class="text-gray-400 hover:text-gray-600 text-2xl">✕</button>
            </div>
            <div id="knowledgeDetailContent" class="flex-1 overflow-y-auto p-6">
                <p class="text-gray-400 text-center animate-pulse">加载中...</p>
            </div>
        </div>
    </div>

    <script>
        let allKnowledge = [];
        let availableTags = [];
        let currentPage = 1;
        let pageSize = 200;  // 每页显示200条
        let totalPages = 1;
        let totalCount = 0;
        let isSearchMode = false;  // 标记是否在搜索模式
        let selectedIds = new Set();  // 选中的知识ID集合

        async function loadTags() {
            const res = await fetch('/api/knowledge/meta/tags');
            const data = await res.json();
            availableTags = data.tags;
            renderTagsFilter();
        }

        function renderTagsFilter() {
            const container = document.getElementById('tagsFilterContainer');
            if (availableTags.length === 0) {
                container.innerHTML = '<p class="text-sm text-gray-500">暂无 tags</p>';
                return;
            }
            container.innerHTML = availableTags.map(tag =>
                `<label class="flex items-center"><input type="checkbox" value="${escapeHtml(tag)}" class="mr-2 tag-filter"> ${escapeHtml(tag)}</label>`
            ).join('');
        }

        async function loadKnowledge(page = 1) {
            const params = new URLSearchParams();
            params.append('page', page);
            params.append('page_size', pageSize);

            const selectedTypes = Array.from(document.querySelectorAll('.type-filter:checked')).map(el => el.value);
            if (selectedTypes.length > 0) {
                params.append('types', selectedTypes.join(','));
            }

            const selectedTags = Array.from(document.querySelectorAll('.tag-filter:checked')).map(el => el.value);
            if (selectedTags.length > 0) {
                params.append('tags', selectedTags.join(','));
            }

            const ownerFilter = document.getElementById('ownerFilter').value.trim();
            if (ownerFilter) {
                params.append('owner', ownerFilter);
            }

            const scopesFilter = document.getElementById('scopesFilter').value.trim();
            if (scopesFilter) {
                params.append('scopes', scopesFilter);
            }

            const selectedStatus = Array.from(document.querySelectorAll('.status-filter:checked')).map(el => el.value);
            if (selectedStatus.length > 0) {
                params.append('status', selectedStatus.join(','));
            }

            try {
                const res = await fetch(`/api/knowledge?${params.toString()}`);
                if (!res.ok) {
                    console.error('加载失败:', res.status, res.statusText);
                    document.getElementById('knowledgeList').innerHTML = '<p class="text-red-500 text-center py-8">加载失败，请刷新页面重试</p>';
                    return;
                }
                const data = await res.json();
                allKnowledge = data.results || [];
                currentPage = data.pagination.page;
                totalPages = data.pagination.total_pages;
                totalCount = data.pagination.total;
                renderKnowledge(allKnowledge);
                updatePagination();
            } catch (error) {
                console.error('加载错误:', error);
                document.getElementById('knowledgeList').innerHTML = '<p class="text-red-500 text-center py-8">加载错误: ' + error.message + '</p>';
            }
        }

        function applyFilters() {
            currentPage = 1;  // 重置到第一页
            loadKnowledge(currentPage);
        }

        function goToPage(page) {
            if (page < 1 || page > totalPages) return;
            loadKnowledge(page);
        }

        function updatePagination() {
            const paginationDiv = document.getElementById('pagination');
            const pageInfo = document.getElementById('pageInfo');
            const prevBtn = document.getElementById('prevBtn');
            const nextBtn = document.getElementById('nextBtn');

            if (totalPages <= 1) {
                paginationDiv.classList.add('hidden');
            } else {
                paginationDiv.classList.remove('hidden');
                pageInfo.textContent = `第 ${currentPage} / ${totalPages} 页 (共 ${totalCount} 条)`;
                prevBtn.disabled = currentPage === 1;
                nextBtn.disabled = currentPage === totalPages;
            }
        }

        async function performSearch() {
            const query = document.getElementById('searchInput').value.trim();
            if (!query) {
                alert('请输入搜索内容');
                return;
            }

            isSearchMode = true;
            const statusDiv = document.getElementById('searchStatus');
            statusDiv.textContent = '搜索中...';
            statusDiv.classList.remove('hidden');

            try {
                const params = new URLSearchParams();
                params.append('q', query);
                params.append('top_k', '20');
                params.append('min_score', '1');  // 搜索时降低最低分数要求

                // 应用筛选条件
                const selectedTypes = Array.from(document.querySelectorAll('.type-filter:checked')).map(el => el.value);
                if (selectedTypes.length > 0) {
                    params.append('types', selectedTypes.join(','));
                }

                const ownerFilter = document.getElementById('ownerFilter').value.trim();
                if (ownerFilter) {
                    params.append('owner', ownerFilter);
                }

                const res = await fetch(`/api/knowledge/search?${params.toString()}`);
                if (!res.ok) {
                    throw new Error(`搜索失败: ${res.status}`);
                }

                const data = await res.json();
                allKnowledge = data.results || [];

                statusDiv.textContent = `找到 ${allKnowledge.length} 条相关知识${data.reranked ? ' (已智能排序)' : ''}`;
                renderKnowledge(allKnowledge);

                // 搜索模式下隐藏分页
                document.getElementById('pagination').classList.add('hidden');
            } catch (error) {
                console.error('搜索错误:', error);
                statusDiv.textContent = '搜索失败: ' + error.message;
                statusDiv.classList.add('text-red-500');
            }
        }

        function clearSearch() {
            document.getElementById('searchInput').value = '';
            document.getElementById('searchStatus').classList.add('hidden');
            document.getElementById('searchStatus').classList.remove('text-red-500');
            isSearchMode = false;
            currentPage = 1;
            loadKnowledge(currentPage);
        }

        function renderKnowledge(list) {
            const container = document.getElementById('knowledgeList');
            if (list.length === 0) {
                container.innerHTML = '<p class="text-gray-500 text-center py-8">暂无知识</p>';
                return;
            }

            container.innerHTML = list.map(k => {
                // 确保types是数组
                let types = [];
                if (Array.isArray(k.types)) {
                    types = k.types;
                } else if (typeof k.types === 'string') {
                    // 如果是JSON字符串（以[开头），尝试解析
                    if (k.types.startsWith('[')) {
                        try {
                            types = JSON.parse(k.types);
                        } catch (e) {
                            console.error('解析types失败:', k.types, e);
                            types = [k.types];
                        }
                    } else {
                        // 如果是普通字符串，包装成数组
                        types = [k.types];
                    }
                }
                const eval_data = k.eval || {};
                const isChecked = selectedIds.has(k.id);
                const statusColor = {
                    'approved': 'bg-green-100 text-green-800',
                    'checked':  'bg-blue-100 text-blue-800',
                    'rejected': 'bg-red-100 text-red-800',
                    'pending':  'bg-yellow-100 text-yellow-800',
                    'processing': 'bg-orange-100 text-orange-800',
                };
                const statusClass = statusColor[k.status] || 'bg-gray-100 text-gray-800';
                const statusLabel = k.status || 'approved';

                // 工具 tag（来自 resource_ids 中 tools/ 前缀的条目）
                const toolIds = (k.resource_ids || []).filter(id => id.startsWith('tools/'));
                const toolTagsHtml = toolIds.length > 0
                    ? `<div class="flex gap-1 flex-wrap mt-2">
                           ${toolIds.map(tid => {
                               const name = tid.split('/').pop();
                               return `<span onclick="event.stopPropagation(); openToolTableModal('${tid}')"
                                             class="text-[11px] px-2 py-0.5 bg-indigo-50 text-indigo-700 border border-indigo-200 rounded-full cursor-pointer hover:bg-indigo-100 transition">
                                           🔧 ${name}
                                       </span>`;
                           }).join('')}
                       </div>`
                    : '';

                return `
                <div class="bg-white rounded-lg shadow p-6 hover:shadow-lg transition relative">
                    <div class="absolute top-4 left-4">
                        <input type="checkbox" class="knowledge-checkbox w-5 h-5 cursor-pointer"
                               data-id="${k.id}" ${isChecked ? 'checked' : ''}
                               onclick="event.stopPropagation(); toggleSelect('${k.id}')">
                    </div>
                    <div class="ml-10 cursor-pointer" onclick="openEditModal('${k.id}')">
                        <div class="flex justify-between items-start mb-2">
                            <div class="flex gap-2 flex-wrap">
                                ${types.map(t => `<span class="bg-blue-100 text-blue-800 text-xs px-2 py-1 rounded">${t}</span>`).join('')}
                            </div>
                            <div class="flex items-center gap-2">
                                <span class="text-xs px-2 py-1 rounded ${statusClass}">${statusLabel}</span>
                                <span class="text-sm text-gray-500">${eval_data.score || 3}/5</span>
                            </div>
                        </div>
                        <h3 class="text-lg font-semibold text-gray-800 mb-2">${escapeHtml(k.task)}</h3>
                        <p class="text-sm text-gray-600 mb-2">${escapeHtml(k.content.substring(0, 150))}${k.content.length > 150 ? '...' : ''}</p>
                        <div class="flex justify-between text-xs text-gray-500">
                            <span>Owner: ${k.owner || 'N/A'}</span>
                            <span>${new Date(k.created_at).toLocaleDateString()}</span>
                        </div>
                        ${toolTagsHtml}
                    </div>
                    <div class="flex gap-2 mt-3 pt-3 border-t border-gray-100">
                        <button onclick="event.stopPropagation(); verifyKnowledge('${k.id}', 'approve', this)"
                                class="${k.status === 'checked' ? 'bg-gray-300 hover:bg-gray-400 text-gray-700' : 'bg-green-400 hover:bg-green-500 text-white'} text-xs px-3 py-1 rounded transition-colors">
                            ${k.status === 'checked' ? '取消验证' : '✓ 验证通过'}
                        </button>
                        <button onclick="event.stopPropagation(); verifyKnowledge('${k.id}', 'reject', this)"
                                class="bg-red-400 hover:bg-red-500 text-white text-xs px-3 py-1 rounded transition-colors">
                            ✗ 拒绝
                        </button>
                    </div>
                </div>
            `;
            }).join('');
        }

        function toggleSelect(id) {
            if (selectedIds.has(id)) {
                selectedIds.delete(id);
            } else {
                selectedIds.add(id);
            }
            updateBatchDeleteButton();
        }

        function toggleSelectAll() {
            if (selectedIds.size === allKnowledge.length) {
                // 全部取消选中
                selectedIds.clear();
            } else {
                // 全部选中
                selectedIds.clear();
                allKnowledge.forEach(k => selectedIds.add(k.id));
            }
            renderKnowledge(allKnowledge);
            updateBatchDeleteButton();
        }

        function updateBatchDeleteButton() {
            const count = selectedIds.size;
            document.getElementById('selectedCount').textContent = count;
            document.getElementById('verifyCount').textContent = count;
            document.getElementById('batchDeleteBtn').disabled = count === 0;
            document.getElementById('batchVerifyBtn').disabled = count === 0;
            document.getElementById('selectAllBtn').textContent =
                selectedIds.size === allKnowledge.length ? '取消全选' : '全选';
        }

        async function batchDelete() {
            if (selectedIds.size === 0) return;

            if (!confirm(`确定要删除选中的 ${selectedIds.size} 条知识吗？此操作不可恢复！`)) {
                return;
            }

            try {
                const ids = Array.from(selectedIds);
                const res = await fetch('/api/knowledge/batch_delete', {
                    method: 'POST',
                    headers: {'Content-Type': 'application/json'},
                    body: JSON.stringify(ids)
                });

                if (!res.ok) {
                    throw new Error(`删除失败: ${res.status}`);
                }

                const data = await res.json();
                alert(`成功删除 ${data.deleted_count} 条知识`);

                // 清空选择并重新加载
                selectedIds.clear();
                updateBatchDeleteButton();

                if (isSearchMode) {
                    clearSearch();
                } else {
                    loadKnowledge(currentPage);
                }
            } catch (error) {
                console.error('批量删除错误:', error);
                alert('删除失败: ' + error.message);
            }
        }

        function openAddModal() {
            document.getElementById('modalTitle').textContent = '新增知识';
            document.getElementById('knowledgeForm').reset();
            document.getElementById('editId').value = '';
            document.querySelectorAll('.type-checkbox').forEach(el => el.checked = false);
            document.getElementById('modal').classList.remove('hidden');
        }

        async function openEditModal(id) {
            let k = allKnowledge.find(item => item.id === id);
            if (!k) {
                // 当前列表中找不到（可能是 rejected/其他状态），通过 API 单独获取
                try {
                    const res = await fetch('/api/knowledge/' + encodeURIComponent(id));
                    if (!res.ok) { alert('知识未找到: ' + id); return; }
                    k = await res.json();
                } catch (e) { alert('获取知识失败: ' + e.message); return; }
            }

            document.getElementById('modalTitle').textContent = '编辑知识';
            document.getElementById('editId').value = k.id;
            document.getElementById('taskInput').value = k.task || '';
            document.getElementById('contentInput').value = k.content || '';
            document.getElementById('tagsInput').value = JSON.stringify(k.tags || {});

            // 防御性检查：确保 scopes 是数组
            const scopes = Array.isArray(k.scopes) ? k.scopes : [];
            document.getElementById('scopesInput').value = scopes.join(', ');

            document.getElementById('ownerInput').value = k.owner || '';

            // 防御性检查：确保 types 是数组
            const types = Array.isArray(k.types) ? k.types : [];
            document.querySelectorAll('.type-checkbox').forEach(el => {
                el.checked = types.includes(el.value);
            });

            // 填充 relationships（可能是 JSON 字符串或数组）
            let rels = [];
            if (Array.isArray(k.relationships)) {
                rels = k.relationships;
            } else if (typeof k.relationships === 'string' && k.relationships.startsWith('[')) {
                try { rels = JSON.parse(k.relationships); } catch(e) {}
            }
            const section = document.getElementById('relationshipsSection');
            if (rels.length > 0) {
                const typeColor = {
                    superset: 'text-green-700', subset: 'text-orange-600',
                    conflict: 'text-red-600', complement: 'text-blue-600',
                    duplicate: 'text-gray-500'
                };
                document.getElementById('relationshipsList').innerHTML = rels.map(r =>
                    `<div class="flex gap-2 items-center">
                        <span class="font-medium ${typeColor[r.type] || 'text-gray-700'}">[${r.type}]</span>
                        <span class="font-mono text-xs text-gray-500 cursor-pointer hover:underline"
                              onclick="openEditModal('${r.target}')">${r.target}</span>
                    </div>`
                ).join('');
                section.classList.remove('hidden');
            } else {
                section.classList.add('hidden');
            }

            document.getElementById('modal').classList.remove('hidden');
        }

        function closeModal() {
            document.getElementById('modal').classList.add('hidden');
        }

        document.getElementById('knowledgeForm').addEventListener('submit', async (e) => {
            e.preventDefault();

            const editId = document.getElementById('editId').value;
            const task = document.getElementById('taskInput').value;
            const content = document.getElementById('contentInput').value;
            const types = Array.from(document.querySelectorAll('.type-checkbox:checked')).map(el => el.value);
            const tagsText = document.getElementById('tagsInput').value.trim();
            const scopesText = document.getElementById('scopesInput').value.trim();
            const owner = document.getElementById('ownerInput').value.trim();

            let tags = {};
            if (tagsText) {
                try {
                    tags = JSON.parse(tagsText);
                } catch (e) {
                    alert('Tags JSON 格式错误');
                    return;
                }
            }

            const scopes = scopesText ? scopesText.split(',').map(s => s.trim()).filter(s => s) : ['org:cybertogether'];

            if (editId) {
                // 编辑
                const res = await fetch(`/api/knowledge/${editId}`, {
                    method: 'PATCH',
                    headers: {'Content-Type': 'application/json'},
                    body: JSON.stringify({task, content, types, tags, scopes, owner})
                });
                if (!res.ok) {
                    alert('更新失败');
                    return;
                }
            } else {
                // 新增
                const res = await fetch('/api/knowledge', {
                    method: 'POST',
                    headers: {'Content-Type': 'application/json'},
                    body: JSON.stringify({task, content, types, tags, scopes, owner})
                });
                if (!res.ok) {
                    alert('新增失败');
                    return;
                }
            }

            closeModal();
            await loadKnowledge();
        });

        async function verifyKnowledge(id, action, btn) {
            if (btn) {
                btn.disabled = true;
                btn._origText = btn.textContent;
                btn.textContent = '处理中...';
            }
            try {
                const res = await fetch('/api/knowledge/' + id + '/verify', {
                    method: 'POST',
                    headers: {'Content-Type': 'application/json'},
                    body: JSON.stringify({ action })
                });
                if (!res.ok) throw new Error('请求失败: ' + res.status);
                if (isSearchMode) {
                    clearSearch();
                } else {
                    loadKnowledge(currentPage);
                }
            } catch (error) {
                console.error('验证错误:', error);
                alert('操作失败: ' + error.message);
                if (btn) {
                    btn.disabled = false;
                    btn.textContent = btn._origText;
                }
            }
        }

        async function batchVerify() {
            if (selectedIds.size === 0) return;
            if (!confirm(`确定要批量验证通过选中的 ${selectedIds.size} 条知识吗？`)) return;
            const btn = document.getElementById('batchVerifyBtn');
            if (btn) { btn.disabled = true; btn.textContent = `处理中...`; }
            try {
                const ids = Array.from(selectedIds);
                const res = await fetch('/api/knowledge/batch_verify', {
                    method: 'POST',
                    headers: {'Content-Type': 'application/json'},
                    body: JSON.stringify({ knowledge_ids: ids, action: 'approve', verified_by: 'user' })
                });
                if (!res.ok) throw new Error('请求失败: ' + res.status);
                selectedIds.clear();
                updateBatchDeleteButton();
                if (isSearchMode) {
                    clearSearch();
                } else {
                    loadKnowledge(currentPage);
                }
            } catch (error) {
                console.error('批量验证错误:', error);
                alert('验证失败: ' + error.message);
                if (btn) { btn.disabled = false; updateBatchDeleteButton(); }
            }
        }

        function escapeHtml(text) {
            const div = document.createElement('div');
            div.textContent = text;
            return div.innerHTML;
        }

        loadTags();
        loadKnowledge();

        // --- 工具表逻辑 ---
        let _allTools = [];
        let _activeCategory = 'all';

        async function openToolTableModal(targetToolId = null) {
            document.getElementById('toolTableModal').classList.remove('hidden');
            if (_allTools.length === 0) {
                await loadToolList();
            } else {
                renderCategoryTabs();
                renderToolList('all');
            }
            if (targetToolId) {
                const targetTool = _allTools.find(t => t.id === targetToolId);
                if (targetTool) {
                    const cat = targetTool.metadata && targetTool.metadata.category ? targetTool.metadata.category : 'other';
                    renderToolList(cat);
                }
                loadToolDetail(targetToolId);
                setTimeout(() => {
                    const el = document.querySelector(`.tool-item[data-id="${targetToolId}"]`);
                    if (el) el.scrollIntoView({ behavior: 'smooth', block: 'center' });
                }, 100);
            }
        }

        function closeToolTableModal() {
            document.getElementById('toolTableModal').classList.add('hidden');
        }

        async function loadToolList() {
            try {
                const res = await fetch('/api/resource?limit=1000');
                const data = await res.json();
                _allTools = (data.results || []).filter(r => r.id.startsWith('tools/'));
                renderCategoryTabs();
                renderToolList('all');
            } catch (err) {
                console.error('加载工具列表失败', err);
                document.getElementById('toolList').innerHTML = '<p class="text-red-500 text-sm text-center">加载失败</p>';
            }
        }

        function renderCategoryTabs() {
            const cats = ['all', ...new Set(_allTools.map(t => t.metadata && t.metadata.category ? t.metadata.category : 'other'))];
            document.getElementById('toolCategoryTabs').innerHTML = cats.map(cat => {
                const isActive = cat === _activeCategory;
                const activeClass = 'bg-indigo-600 text-white border-indigo-600';
                const inactiveClass = 'bg-white text-gray-600 border-gray-300 hover:border-indigo-400';
                return `<button onclick="renderToolList('${cat}')"
                                id="tab_${cat}"
                                class="tool-cat-tab px-4 py-1.5 rounded-full text-sm font-medium border transition ${isActive ? activeClass : inactiveClass}">
                            ${cat === 'all' ? '全部' : cat}
                        </button>`;
            }).join('');
        }

        function renderToolList(category) {
            _activeCategory = category;
            document.querySelectorAll('.tool-cat-tab').forEach(btn => {
                const isCurrent = btn.id === `tab_${category}`;
                btn.className = `tool-cat-tab px-4 py-1.5 rounded-full text-sm font-medium border transition ${
                    isCurrent ? 'bg-indigo-600 text-white border-indigo-600' : 'bg-white text-gray-600 border-gray-300 hover:border-indigo-400'
                }`;
            });
            const filtered = category === 'all'
                ? _allTools
                : _allTools.filter(t => (t.metadata && t.metadata.category ? t.metadata.category : 'other') === category);
            const listHtml = filtered.length === 0
                ? '<p class="text-sm text-gray-400 text-center mt-4">该分类下暂无工具</p>'
                : filtered.map(t => `
                    <div onclick="loadToolDetail('${t.id}')"
                         class="tool-item p-3 rounded-lg border border-gray-200 cursor-pointer hover:border-indigo-400 hover:shadow-sm bg-white transition"
                         data-id="${t.id}">
                        <div class="font-bold text-gray-800 text-sm truncate" title="${escapeHtml(t.title || t.id)}">${escapeHtml(t.title || t.id.split('/').pop())}</div>
                        <div class="mt-1 flex items-center justify-between">
                            <span class="text-xs px-2 py-0.5 rounded truncate max-w-[100px] ${(t.metadata && t.metadata.status === '已接入') ? 'bg-green-100 text-green-700' : 'bg-gray-100 text-gray-600'}">${escapeHtml(t.metadata && t.metadata.status ? t.metadata.status : '未设置')}</span>
                            <span class="text-[10px] text-gray-400">${escapeHtml(t.content_type || '')}</span>
                        </div>
                    </div>`).join('');
            document.getElementById('toolList').innerHTML = listHtml;
        }

        async function loadToolDetail(id) {
            document.querySelectorAll('.tool-item').forEach(el => {
                if (el.dataset.id === id) {
                    el.classList.add('border-indigo-500', 'ring-1', 'ring-indigo-500');
                    el.classList.remove('border-gray-200');
                } else {
                    el.classList.remove('border-indigo-500', 'ring-1', 'ring-indigo-500');
                    el.classList.add('border-gray-200');
                }
            });
            const detailEl = document.getElementById('toolDetail');
            detailEl.innerHTML = '<div class="flex h-full items-center justify-center"><p class="text-gray-400 animate-pulse">加载详情中...</p></div>';
            try {
                const res = await fetch('/api/resource/' + id);
                const tool = await res.json();
                const knowledgeIds = (tool.metadata && tool.metadata.knowledge_ids) ? tool.metadata.knowledge_ids : [];
                const knowledgeHtml = knowledgeIds.length === 0
                    ? '<span class="text-gray-400 text-xs">暂无</span>'
                    : knowledgeIds.map(kid => `
                        <span onclick="openKnowledgeDetailModal('${kid}')"
                              class="text-xs px-2 py-1 bg-gray-100 hover:bg-gray-200 border rounded cursor-pointer text-gray-700 font-mono transition">
                            ${kid.length > 24 ? kid.slice(0, 24) + '...' : kid}
                        </span>`).join('');

                const toolhubItems = (tool.metadata && tool.metadata.toolhub_items) ? tool.metadata.toolhub_items : [];
                const toolhubHtml = toolhubItems.length === 0
                    ? '<span class="text-gray-400 text-xs">暂无</span>'
                    : toolhubItems.map(item => {
                        const [id, desc] = Object.entries(item)[0];
                        return `<span class="text-xs px-2 py-1 bg-blue-50 hover:bg-blue-100 border border-blue-200 rounded text-blue-700 font-mono transition">
                            ${escapeHtml(id)}: ${escapeHtml(desc)}
                        </span>`;
                    }).join('');

                const meta = tool.metadata || {};
                const scenariosMd = Array.isArray(meta.scenarios) && meta.scenarios.length > 0
                    ? meta.scenarios.map(s => `<li>${escapeHtml(s)}</li>`).join('')
                    : '<li class="text-gray-400">暂无</li>';

                detailEl.innerHTML = `
                    <div class="mb-6 border-b pb-4">
                        <h2 class="text-3xl font-black text-gray-900 mb-3">${escapeHtml(tool.title || id)}</h2>
                        <div class="flex gap-2 flex-wrap text-sm mb-3">
                            <span class="px-2.5 py-1 bg-indigo-50 text-indigo-700 rounded-md border border-indigo-100">
                                📁 分类: ${escapeHtml(meta.category || '–')}
                            </span>
                            <span class="px-2.5 py-1 rounded-md border ${(meta.status === '已接入') ? 'bg-green-50 text-green-700 border-green-200' : 'bg-gray-50 text-gray-700 border-gray-200'}">
                                🏷️ 状态: ${escapeHtml(meta.status || '–')}
                            </span>
                            <span class="px-2.5 py-1 bg-blue-50 text-blue-700 rounded-md border border-blue-100">
                                📌 Slug: ${escapeHtml(meta.tool_slug || '–')}
                            </span>
                        </div>
                        <div class="flex gap-1 flex-wrap items-center">
                            <span class="text-xs text-gray-500 mr-1">🔗 关联知识:</span>
                            ${knowledgeHtml}
                        </div>
                        <div class="flex gap-1 flex-wrap items-center mt-2">
                            <span class="text-xs text-gray-500 mr-1">🔧 工具项:</span>
                            ${toolhubHtml}
                        </div>
                    </div>

                    <div class="text-gray-800 leading-relaxed max-w-none space-y-6">
                        <div>
                            <h3 class="text-lg font-bold border-b pb-2 mb-3">基础概览</h3>
                            <div class="grid grid-cols-1 md:grid-cols-2 gap-4 text-sm">
                                <div><span class="text-gray-500 font-semibold">工具版本:</span> ${escapeHtml(meta.version || '–')}</div>
                            </div>
                            <div class="mt-3">
                                <span class="text-gray-500 font-semibold text-sm block mb-1">功能介绍:</span>
                                <div class="bg-gray-50 p-3 rounded-md text-sm border">${escapeHtml(meta.description || '暂无')}</div>
                            </div>
                        </div>

                        <div>
                            <h3 class="text-lg font-bold border-b pb-2 mb-3">使用指南</h3>
                            <div class="mb-4">
                                <span class="text-gray-500 font-semibold text-sm block mb-1">用法:</span>
                                <div class="bg-gray-50 p-3 rounded-md text-sm border whitespace-pre-wrap">${escapeHtml(meta.usage || '暂无')}</div>
                            </div>
                            <div>
                                <span class="text-gray-500 font-semibold text-sm block mb-1">应用场景:</span>
                                <ul class="list-disc pl-5 space-y-1 text-sm">${scenariosMd}</ul>
                            </div>
                        </div>

                        <div>
                            <h3 class="text-lg font-bold border-b pb-2 mb-3">技术规格</h3>
                            <div class="grid grid-cols-1 md:grid-cols-2 gap-6">
                                <div>
                                    <span class="text-gray-500 font-semibold text-sm block mb-1">输入:</span>
                                    <div class="bg-gray-50 p-3 rounded-md text-sm border h-full">${escapeHtml(meta.input || '暂无')}</div>
                                </div>
                                <div>
                                    <span class="text-gray-500 font-semibold text-sm block mb-1">输出:</span>
                                    <div class="bg-gray-50 p-3 rounded-md text-sm border h-full">${escapeHtml(meta.output || '暂无')}</div>
                                </div>
                            </div>
                        </div>

                        ${meta.source ? `
                        <div>
                            <h3 class="text-lg font-bold border-b pb-2 mb-3">消息信源</h3>
                            <div class="text-sm overflow-hidden break-words text-blue-600 hover:underline">
                                ${escapeHtml(meta.source)}
                            </div>
                        </div>` : ''}

                        ${tool.body ? `
                        <div class="pt-4 mt-6 border-t border-dashed">
                            <h3 class="text-lg font-bold mb-3 text-gray-500">补充说明 (文档内容)</h3>
                            <div class="markdown-body bg-gray-50 p-4 rounded-lg border text-sm">
                                ${typeof marked !== 'undefined' ? marked.parse(tool.body) : escapeHtml(tool.body)}
                            </div>
                        </div>` : ''}
                    </div>`;
            } catch (err) {
                detailEl.innerHTML = '<div class="text-red-500 flex h-full items-center justify-center">加载详情失败，请检查网络或日志</div>';
                console.error(err);
            }
        }

        async function openKnowledgeDetailModal(id) {
            document.getElementById('knowledgeDetailModal').classList.remove('hidden');
            const contentEl = document.getElementById('knowledgeDetailContent');
            contentEl.innerHTML = '<p class="text-gray-400 text-center animate-pulse">加载中...</p>';
            try {
                const res = await fetch(`/api/knowledge/${encodeURIComponent(id)}`);
                if (!res.ok) { contentEl.innerHTML = '<p class="text-red-500 text-center">知识未找到</p>'; return; }
                const k = await res.json();
                const statusColor = {
                    'approved': 'bg-green-100 text-green-800',
                    'checked':  'bg-blue-100 text-blue-800',
                    'rejected': 'bg-red-100 text-red-800',
                    'pending':  'bg-yellow-100 text-yellow-800',
                };
                const types = Array.isArray(k.types) ? k.types : [];
                const tags = k.tags || {};
                const tagKeys = Object.keys(tags);
                contentEl.innerHTML = `
                    <div class="flex gap-2 flex-wrap mb-4">
                        ${types.map(t => `<span class="px-2 py-0.5 bg-blue-100 text-blue-700 rounded text-xs">${escapeHtml(t)}</span>`).join('')}
                        <span class="px-2 py-0.5 rounded text-xs ${statusColor[k.status] || 'bg-gray-100 text-gray-700'}">${escapeHtml(k.status || '–')}</span>
                    </div>
                    <h3 class="text-lg font-bold text-gray-900 mb-3">${escapeHtml(k.task || '')}</h3>
                    <div class="text-sm text-gray-700 bg-gray-50 rounded-lg p-4 mb-4 whitespace-pre-wrap leading-relaxed">
                        ${escapeHtml(k.content || '')}
                    </div>
                    <div class="text-xs text-gray-500 space-y-1 border-t pt-3">
                        <div>📌 ID：<span class="font-mono">${escapeHtml(k.id || '')}</span></div>
                        <div>👤 Owner：${escapeHtml(k.owner || '–')}</div>
                        <div>🕐 创建：${k.created_at ? new Date(k.created_at * 1000).toLocaleString() : '–'}</div>
                        ${tagKeys.length > 0 ? `<div>🏷️ Tags：${tagKeys.map(t => `<span class="bg-gray-100 px-1 rounded">${escapeHtml(t)}</span>`).join(' ')}</div>` : ''}
                    </div>`;
            } catch (err) {
                contentEl.innerHTML = '<p class="text-red-500 text-center">加载失败</p>';
                console.error(err);
            }
        }

        function closeKnowledgeDetailModal() {
            document.getElementById('knowledgeDetailModal').classList.add('hidden');
        }
    </script>
</body>
</html>"""

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=9999)