# 医学模型配置
OPENAI_BASE_URL=https://api.tbox.cn/api/llm/v1/  # 模型基础地址，可按实际支持调整
OPENAI_API_KEY=your-token-here                   # 替换为模型调用的实际API密钥
MODEL_NAME=AntAngelMed                           # 模型名称，固定为AntAngelMed

import os
import yaml
import importlib
from typing import Dict, Any
class SkillRegistry:
    """
    SKILL技能注册中心（核心组件）
    作用：扫描skills目录下的所有技能，加载技能元数据，提供技能匹配、实例化功能
    特点：自动加载、动态管理，新增技能无需修改核心代码，直接放入skills目录即可
    """
    def __init__(self, skill_dir="skills"):
        self.skill_dir = skill_dir  # 技能存放目录（默认skills）
        self.skills: Dict[str, Any] = {}  # 存储所有加载的技能（key：技能名称，value：技能元数据）
        self.load_all_skills()  # 初始化时加载所有技能
    def load_all_skills(self):
        """加载skills目录下的所有SKILL技能，自动解析SKILL.md元数据"""
        self.skills.clear()  # 清空技能列表，避免重复加载
        # 遍历skills目录下的所有文件夹（每个文件夹对应一个技能）
        for name in os.listdir(self.skill_dir):
            path = os.path.join(self.skill_dir, name)
            if os.path.isdir(path):  # 只处理文件夹（排除文件）
                self.load_skill(path)  # 加载单个技能
        # 打印加载结果，便于开发调试
        print(f"✅ 慢病管理技能加载完成：共加载 {len(self.skills)} 个技能")
        print(f"📋 已加载技能：{[name for name in self.skills.keys()]}")
    def load_skill(self, path):
        """加载单个技能，解析SKILL.md中的元数据"""
        # 找到技能的SKILL.md文件（核心配置文件，必须存在）
        md_path = os.path.join(path, "SKILL.md")
        if not os.path.exists(md_path):
            print(f"⚠️  跳过无效技能：{os.path.basename(path)}（缺少SKILL.md文件）")
            return
        # 读取并解析SKILL.md中的YAML元数据（机器可解析部分）
        with open(md_path, 'r', encoding='utf-8') as f:
            content = f.read()
            # SKILL.md采用YAML+Markdown混合格式，提取YAML部分（---之间的内容）
            if '---' in content:
                yaml_content = content.split('---')[1]
                skill_meta = yaml.safe_load(yaml_content)
                # 记录技能的模块路径，用于后续实例化
                skill_meta['module'] = f"skills.{os.path.basename(path)}.impl"
                # 将技能元数据存入技能列表
                self.skills[skill_meta['name']] = skill_meta
                print(f"✅ 加载技能：{skill_meta['name']}（{skill_meta['description']}）")
    def match(self, query):
        """
        根据用户查询内容，匹配最适合的SKILL技能
        匹配规则：根据技能的trigger.keywords（触发关键词），匹配用户查询中的关键词
        返回：匹配到的技能列表（按匹配度排序，第一个为最优匹配）
        """
        matched_skills = []
        # 将用户查询转为小写，避免大小写影响匹配
        user_query = query.lower()
        # 遍历所有已加载的技能，匹配关键词
        for skill in self.skills.values():
            # 检查用户查询是否包含当前技能的触发关键词
            for keyword in skill['trigger']['keywords']:
                if keyword.lower() in user_query:
                    matched_skills.append(skill)
                    break  # 匹配到一个关键词即可，无需重复匹配
        return matched_skills
    def get_instance(self, skill_name):
        """
        根据技能名称，获取技能实例（用于执行技能逻辑）
        原理：通过importlib导入技能的impl.py模块，调用get_skill()方法获取实例
        """
        if skill_name not in self.skills:
            raise ValueError(f"❌ 技能不存在：{skill_name}（请检查技能名称或是否已加载）")
        # 获取技能的模块路径（如：skills.diabetes_assess.impl）
        skill_module = self.skills[skill_name]['module']
        # 导入技能模块
        mod = importlib.import_module(skill_module)
        # 返回技能实例（每个技能的impl.py都必须实现get_skill()方法）
        return mod.get_skill()

from fastapi import FastAPI, WebSocket, WebSocketDisconnect
from fastapi.staticfiles import StaticFiles
from fastapi.responses import FileResponse
from openai import OpenAI
import os
import asyncio
from dotenv import load_dotenv
from skill_registry import SkillRegistry
# 加载.env环境变量（优先加载敏感配置，避免硬编码）
load_dotenv()
# 初始化FastAPI应用（后端服务核心）
app = FastAPI(
    title="糖尿病&高血压慢病管理SKILL智能体",
    description="基于SKILL架构、AntAngelMed医学模型的全栈慢病管理系统，提供实时咨询、个性化指导服务",
    version="1.0.0"
)
# 挂载前端静态资源（让后端能够访问static目录下的index.html）
app.mount("/static", StaticFiles(directory="static"), name="static")
# 初始化SKILL技能注册中心（加载所有慢病管理技能）
registry = SkillRegistry()
# 初始化医学模型客户端（严格按照你提供的调用格式配置）
model_client = OpenAI(
    base_url=os.getenv("OPENAI_BASE_URL"),  # 从.env读取模型基础地址
    api_key=os.getenv("OPENAI_API_KEY")     # 从.env读取API密钥
)
class ConnectionManager:
    """
    WebSocket连接管理类
    作用：管理所有前端连接，实现消息发送、连接建立/断开等功能
    确保多用户同时访问时，对话不冲突、不串线
    """
    def __init__(self):
        self.active_connections = []  # 存储当前活跃的WebSocket连接
    async def connect(self, websocket: WebSocket):
        """建立WebSocket连接，接收前端请求"""
        await websocket.accept()  # 接受前端连接
        self.active_connections.append(websocket)  # 将连接加入活跃列表
        print(f"🔗 新用户连接：当前在线人数 {len(self.active_connections)}")
    def disconnect(self, websocket: WebSocket):
        """断开WebSocket连接，清理资源"""
        self.active_connections.remove(websocket)  # 从活跃列表中移除连接
        print(f"🔌 用户断开连接：当前在线人数 {len(self.active_connections)}")
    async def send_message(self, message: str, websocket: WebSocket):
        """向指定前端连接发送消息（实时对话核心）"""
        await websocket.send_text(message)  # 发送文本消息
# 实例化连接管理器
conn_manager = ConnectionManager()
def call_medical_model(prompt: str) -> str:
    """
    调用AntAngelMed医学模型，获取专业医学建议
    参数：prompt - 经过格式化的用户查询（结合技能需求，优化提问方式）
    返回：模型返回的医学建议（字符串），异常时返回友好提示
    """
    try:
        # 严格按照你提供的格式调用模型
        response = model_client.chat.completions.create(
            model=os.getenv("MODEL_NAME"),  # 模型名称（AntAngelMed）
            messages=[{"role": "user", "content": prompt}]  # 消息格式（仅用户角色）
        )
        # 提取模型返回的内容（取第一个结果）
        return response.choices[0].message.content
    except Exception as e:
        # 捕获模型调用异常，返回友好提示（避免用户看到技术错误）
        return f"⚠️  医学咨询暂时无法响应，请稍后再试（错误信息：{str(e)[:50]}）"
def execute_skill_flow(user_query: str) -> str:
    """
    技能执行流程（核心逻辑）
    步骤：1. 匹配用户查询对应的SKILL技能 → 2. 执行技能逻辑 → 3. 返回结果
    若未匹配到技能，直接调用医学模型进行通用咨询
    """
    # 1. 匹配技能（根据用户查询中的关键词，找到最适合的技能）
    matched_skills = registry.match(user_query)
    
    # 2. 执行技能（若匹配到技能，优先执行技能逻辑；否则直接调用模型）
    if not matched_skills:
        # 未匹配到技能，直接调用医学模型，进行通用慢病咨询
        print(f"🔍 未匹配到具体技能，直接调用医学模型处理：{user_query}")
        return call_medical_model(f"请作为专业的糖尿病、高血压慢病管理助手，简洁、专业、可执行地回答用户问题：{user_query}")
    else:
        # 匹配到技能，优先执行最优技能（第一个匹配到的技能）
        best_skill = matched_skills[0]
        print(f"🔍 匹配到技能：{best_skill['name']}，执行技能逻辑")
        # 获取技能实例，执行技能
        skill_instance = registry.get_instance(best_skill['name'])
        # 调用技能的execute方法，传入用户查询数据
        skill_result = skill_instance.execute({"query": user_query})
        # 统一处理字典格式，只返回建议文本
        if isinstance(skill_result, dict):
            return skill_result.get("result", "暂无建议")
        return str(skill_result)
        # return skill_result
# 前端页面访问路由（用户访问根路径时，返回前端对话页面）
@app.get("/")
def home_page():
    """返回前端实时对话页面，用户交互入口"""
    return FileResponse("static/index.html")
# WebSocket实时对话路由（核心交互接口）
@app.websocket("/ws")
async def websocket_endpoint(websocket: WebSocket):
    """
    WebSocket实时对话处理逻辑
    作用：接收前端用户输入，执行技能/模型调用，返回实时响应
    """
    # 建立WebSocket连接
    await conn_manager.connect(websocket)
    try:
        # 循环监听前端消息（持续接收用户输入）
        while True:
            # 接收前端发送的用户查询（文本消息）
            user_message = await websocket.receive_text()
            # 向用户发送“用户输入”提示（便于用户区分自己和AI的消息）
            await conn_manager.send_message(f"👤 你：{user_message}", websocket)
            # 向用户发送“AI思考中”提示（提升用户体验，避免用户以为系统无响应）
            await conn_manager.send_message(f"⚕️ 慢病助手：正在为你分析...", websocket)
            
            # 执行技能/模型调用（使用asyncio.to_thread，避免阻塞WebSocket连接）
            response_result = await asyncio.to_thread(execute_skill_flow, user_message)
            
            # 向用户发送AI的响应结果（格式化显示，清晰易懂）
            await conn_manager.send_message(f"✅ 慢病助手：{response_result}", websocket)
    except WebSocketDisconnect:
        # 捕获用户断开连接异常，清理连接资源
        conn_manager.disconnect(websocket)
    except Exception as e:
        # 捕获其他异常，向用户发送友好提示
        await conn_manager.send_message(f"❌ 系统异常：{str(e)[:50]}，请稍后再试", websocket)
        conn_manager.disconnect(websocket)
# 启动服务（直接运行main.py即可启动，无需额外配置）
if __name__ == "__main__":
    import uvicorn
    print("🚀 慢病管理智能体服务启动中...")
    print("📌 访问地址：http://127.0.0.1:8000")
    print("💡 提示：请确保.env文件中的API密钥配置正确，否则无法调用医学模型")
    # 启动uvicorn服务器，监听0.0.0.0:8000（可通过IP访问，支持局域网共享）
    uvicorn.run(app, host="0.0.0.0", port=8000)

from openai import OpenAI
import os
from dotenv import load_dotenv
# 加载.env环境变量（获取模型配置，避免硬编码）
load_dotenv()
# 初始化医学模型客户端（严格按照用户提供的格式配置）
medical_client = OpenAI(
    base_url=os.getenv("OPENAI_BASE_URL"),
    api_key=os.getenv("OPENAI_API_KEY")
)
class DiabetesAssessSkill:
    """
    糖尿病评估技能类（核心逻辑：处理糖尿病相关咨询，调用医学模型返回专业建议）
    方法：execute - 执行技能，接收用户查询，返回格式化结果
    """
    def execute(self, input_data: dict) -> dict:
        """
        执行糖尿病评估技能
        参数：input_data - 包含用户查询的字典（key: query，value: 用户输入的问题）
        返回：字典，包含技能执行结果、状态、提示信息（符合output_schema规范）
        """
        try:
            # 1. 提取用户查询（从input_data中获取，确保参数存在）
            user_query = input_data.get("query", "").strip()
            if not user_query:
                # 若用户查询为空，返回失败结果
                return {
                    "result": "",
                    "success": False,
                    "message": "请输入具体的糖尿病相关问题（如：空腹血糖7.0严重吗？）"
                }
            # 2. 格式化prompt（优化提问方式，让模型返回更精准、可执行的建议）
            prompt = f"""你是专业的糖尿病慢病管理医生，根据用户的问题，提供简洁、专业、可执行的医学建议，要求如下：
1.  语言通俗易懂，避免过于晦涩的专业术语，适配普通糖尿病患者理解；
2.  建议具体、可落地，比如饮食、运动建议要明确“能吃什么、不能吃什么”“运动时间、方式”；
3.  若用户涉及血糖异常，需明确告知正常范围，并给出具体的控制建议；
4.  若用户症状可能涉及严重情况，需提示“及时就医”，不替代专业诊断；
5.  聚焦糖尿病相关内容，不回答与糖尿病无关的问题；
6.  篇幅适中，避免过长，重点突出核心建议。
用户问题：{user_query}"""
            # 3. 调用AntAngelMed医学模型（严格按照用户提供的格式）
            model_response = medical_client.chat.completions.create(
                model=os.getenv("MODEL_NAME"),  # 模型名称：AntAngelMed
                messages=[{"role": "user", "content": prompt}]  # 消息格式
            )
            # 4. 提取模型返回结果，格式化输出（符合output_schema规范）
            return {
                "result": model_response.choices[0].message.content,
                "success": True,
                "message": "技能执行成功"
            }
        except Exception as e:
            # 捕获所有异常（模型调用失败、超时等），返回友好提示
            return {
                "result": "",
                "success": False,
                "message": f"技能执行失败：{str(e)[:50]}（请稍后再试）"
            }
def get_skill():
    """
    技能入口函数（必须实现，供SkillRegistry调用，返回技能实例）
    返回：DiabetesAssessSkill实例
    """
    return DiabetesAssessSkill()

from openai import OpenAI
import os
from dotenv import load_dotenv
load_dotenv()
# 初始化医学模型客户端
medical_client = OpenAI(
    base_url=os.getenv("OPENAI_BASE_URL"),
    api_key=os.getenv("OPENAI_API_KEY")
)
class HypertensionAssessSkill:
    """高血压评估技能类，处理高血压相关咨询，调用医学模型返回专业建议"""
    def execute(self, input_data: dict) -> dict:
        try:
            # 提取用户查询
            user_query = input_data.get("query", "").strip()
            if not user_query:
                return {
                    "result": "",
                    "success": False,
                    "message": "请输入具体的高血压相关问题（如：血压150/95需要吃药吗？）"
                }
            # 格式化prompt，优化模型响应
            prompt = f"""你是专业的高血压慢病管理医生，根据用户的问题，提供简洁、专业、可执行的医学建议，要求如下：
1.  语言通俗易懂，避免晦涩的专业术语，适配普通高血压患者理解；
2.  建议具体可落地，比如饮食、运动建议明确具体做法和用量；
3.  解读血压数值时，明确告知正常范围和当前血压等级；
4.  涉及用药建议时，强调“遵医嘱”，不自行推荐具体药物；
5.  若用户症状紧急，提示“立即就医”，不替代专业诊断；
6.  聚焦高血压相关内容，不回答无关问题，篇幅适中。
用户问题：{user_query}"""
            # 调用AntAngelMed模型
            model_response = medical_client.chat.completions.create(
                model=os.getenv("MODEL_NAME"),
                messages=[{"role": "user", "content": prompt}]
            )
            # 返回格式化结果
            return {
                "result": model_response.choices[0].message.content,
                "success": True,
                "message": "技能执行成功"
            }
        except Exception as e:
            return {
                "result": "",
                "success": False,
                "message": f"技能执行失败：{str(e)[:50]}（请稍后再试）"
            }
def get_skill():
    """技能入口，返回技能实例"""
    return HypertensionAssessSkill()

from openai import OpenAI
import os
from dotenv import load_dotenv
load_dotenv()
medical_client = OpenAI(
    base_url=os.getenv("OPENAI_BASE_URL"),
    api_key=os.getenv("OPENAI_API_KEY")
)
class DietGuideSkill:
    def execute(self, input_data: dict) -> dict:
        try:
            user_query = input_data.get("query", "").strip()
            if not user_query:
                return {
                    "result": "",
                    "success": False,
                    "message": "请输入具体的饮食问题"
                }
            prompt = f"""你是专业的慢病营养师，专门为糖尿病+高血压双慢病患者提供饮食指导。
要求：
1. 同时兼顾“低糖、低盐、低脂”三大原则，不能顾此失彼。
2. 语言通俗、具体、可执行，给出明确的“能吃/少吃/禁止”。
3. 食谱要实用，适合家庭日常，不要复杂食材。
4. 不使用专业术语堆砌，中老年能看懂。
5. 不提供处方类建议，只做饮食指导。
用户问题：{user_query}
"""
            resp = medical_client.chat.completions.create(
                model=os.getenv("MODEL_NAME"),
                messages=[{"role": "user", "content": prompt}]
            )
            return {
                "result": resp.choices[0].message.content,
                "success": True,
                "message": "ok"
            }
        except Exception as e:
            return {
                "result": "",
                "success": False,
                "message": f"饮食建议获取失败：{str(e)}"
            }
def get_skill():
    return DietGuideSkill()

from openai import OpenAI
import os
from dotenv import load_dotenv
load_dotenv()
client = OpenAI(base_url=os.getenv("OPENAI_BASE_URL"), api_key=os.getenv("OPENAI_API_KEY"))
class RiskWarningSkill:
    def execute(self, data):
        try:
            q = data["query"].strip()
            prompt = f"""你是专业慢病急诊助手，判断糖尿病/高血压相关风险等级：
- 明确标注：低危 / 中危 / 高危 / 危急
- 简要说明危害
- 给出立即行动建议（观察/就医/急诊）
- 语言严肃、清晰、简短
用户描述：{q}
"""
            res = client.chat.completions.create(
                model=os.getenv("MODEL_NAME"),
                messages=[{"role":"user","content":prompt}]
            )
            return {
                "result": res.choices[0].message.content,
                "success": True,
                "message": "ok"
            }
        except Exception as e:
            return {"result":"","success":False,"message":str(e)}
def get_skill():
    return RiskWarningSkill()