# tools.py —— 三种方案共享的工具实现

import json

def calculator(expression: str) -> str:
    """
    演示版：计算数学表达式。
    这里用字符白名单 + eval 做简化实现，便于聚焦后文三种工具调用方案。
    """
    allowed = set("0123456789+-*/.() ")
    if not all(c in allowed for c in expression):
        return json.dumps({"error": f"包含不允许的字符"}, ensure_ascii=False)
    try:
        result = eval(expression)
        return json.dumps({"result": result})
    except Exception as e:
        return json.dumps({"error": str(e)})


def get_weather(city: str) -> str:
    """
    查询城市天气（这里用模拟数据，实际项目应调用真实 API）。
    """
    mock_db = {
        "北京": {"temperature": 18, "condition": "晴", "humidity": "35%"},
        "上海": {"temperature": 22, "condition": "多云", "humidity": "65%"},
        "广州": {"temperature": 28, "condition": "小雨", "humidity": "80%"},
    }
    info = mock_db.get(city, {"temperature": "未知", "condition": "未知", "humidity": "未知"})
    return json.dumps({"city": city, **info}, ensure_ascii=False)


# 工具名到函数的映射，后面会用到
TOOL_MAP = {
    "calculator": calculator,
    "get_weather": get_weather,
}

"""
方案一：Function Call
依赖：pip install openai
环境变量：OPENAI_API_KEY
"""

import json
from openai import OpenAI
from tools import TOOL_MAP  # 导入前面定义的共享工具

# ======== 第一步：用 JSON Schema 描述工具 ========
# 这些定义会随 API 请求发给 LLM，让它知道有哪些工具可用

TOOLS_SCHEMA = [
    {
        "type": "function",
        "function": {
            "name": "calculator",
            "description": "计算数学表达式。当需要做加减乘除等数学运算时使用。",
            "parameters": {
                "type": "object",
                "properties": {
                    "expression": {
                        "type": "string",
                        "description": "要计算的数学表达式，例如 '(3 + 5) * 2'"
                    }
                },
                "required": ["expression"],
                "additionalProperties": False
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "查询指定城市的当前天气信息。",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {
                        "type": "string",
                        "description": "要查询天气的城市名称，例如 '北京'"
                    }
                },
                "required": ["city"],
                "additionalProperties": False
            }
        }
    }
]


def run():
    client = OpenAI()  # 自动读取环境变量 OPENAI_API_KEY

    messages = [
        {"role": "system", "content": "你是一个助手，可以查天气和做数学计算。请使用工具来完成任务。"},
        {"role": "user", "content": "北京今天多少度？另外帮我算一下 42 × 38"}
    ]

    # ======== 第二步：第一次 API 调用 —— LLM 决定调用哪些工具 ========
    print("发送请求（用户消息 + 工具定义）...")
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=messages,
        tools=TOOLS_SCHEMA,
        tool_choice="auto",  # "auto" 表示让 LLM 自己判断要不要调工具
    )

    msg = response.choices[0].message

    # 检查 LLM 是否决定调用工具
    if not msg.tool_calls:
        print(f"LLM 直接回复了：{msg.content}")
        return

    print(f"LLM 决定调用 {len(msg.tool_calls)} 个工具")

    # ======== 第三步：执行工具，收集结果 ========
    # 先把 LLM 的回复（含 tool_calls）加入对话历史
    messages.append(msg.model_dump())

    for call in msg.tool_calls:
        name = call.function.name
        args = json.loads(call.function.arguments)

        print(f"  执行 {name}({args})")
        result = TOOL_MAP[name](**args)
        print(f"  结果：{result}")

        # 把每个工具的结果以 role="tool" 加入对话
        # tool_call_id 必须与对应的 call.id 匹配
        messages.append({
            "role": "tool",
            "tool_call_id": call.id,
            "content": result,
        })

    # ======== 第四步：第二次 API 调用 —— LLM 根据结果生成回复 ========
    print("发送工具结果，请求最终回复...")
    final = client.chat.completions.create(
        model="gpt-4o",
        messages=messages,
    )

    print(f"\n最终回复：{final.choices[0].message.content}")


if __name__ == "__main__":
    run()

{
  "model": "gpt-4o",
  "messages": [
    {"role": "user", "content": "北京今天多少度？另外帮我算一下 42 × 38"}
  ],
  "tools": [
    {
      "type": "function",
      "function": {
        "name": "get_weather",
        "description": "查询指定城市的当前天气信息。",
        "parameters": { "type": "object", "properties": { "city": { "type": "string" } }, "required": ["city"] }
      }
    },
    {
      "type": "function",
      "function": {
        "name": "calculator",
        "description": "计算数学表达式。",
        "parameters": { "type": "object", "properties": { "expression": { "type": "string" } }, "required": ["expression"] }
      }
    }
  ]
}

{
  "choices": [{
    "message": {
      "role": "assistant",
      "content": null,
      "tool_calls": [
        {
          "id": "call_abc123",
          "type": "function",
          "function": { "name": "get_weather", "arguments": "{\"city\":\"北京\"}" }
        },
        {
          "id": "call_def456",
          "type": "function",
          "function": { "name": "calculator", "arguments": "{\"expression\":\"42 * 38\"}" }
        }
      ]
    },
    "finish_reason": "tool_calls"
  }]
}

# 在工具定义中开启 strict mode
{
    "type": "function",
    "function": {
        "name": "calculator",
        "strict": True,  # ← 加上这个
        "parameters": {
            "type": "object",
            "properties": { "expression": { "type": "string" } },
            "required": ["expression"],
            "additionalProperties": False  # ← strict mode 要求此项为 False
        }
    }
}

"""
MCP Server —— 提供 calculator 和 get_weather 工具
依赖：pip install "mcp[cli]"
运行：python mcp_server.py（会以 stdio 模式启动，等待 Client 连接）
"""

import json
from mcp.server.fastmcp import FastMCP

# 创建 Server 实例，名称用于标识
server = FastMCP("demo-tools")


# 用 @server.tool() 装饰器注册工具
# MCP SDK 会自动从函数签名和 docstring 提取工具的名称、描述、参数 Schema
@server.tool()
def calculator(expression: str) -> str:
    """
    计算数学表达式，支持加减乘除和括号。

    Args:
        expression: 要计算的数学表达式，例如 "(3 + 5) * 2"
    """
    allowed = set("0123456789+-*/.() ")
    if not all(c in allowed for c in expression):
        return json.dumps({"error": "包含不允许的字符"}, ensure_ascii=False)
    try:
        result = eval(expression)
        return json.dumps({"result": result})
    except Exception as e:
        return json.dumps({"error": str(e)})


@server.tool()
def get_weather(city: str) -> str:
    """
    查询指定城市的当前天气。

    Args:
        city: 城市名称，例如 "北京"
    """
    mock_db = {
        "北京": {"temperature": 18, "condition": "晴", "humidity": "35%"},
        "上海": {"temperature": 22, "condition": "多云", "humidity": "65%"},
        "广州": {"temperature": 28, "condition": "小雨", "humidity": "80%"},
    }
    info = mock_db.get(city, {"temperature": "未知", "condition": "未知", "humidity": "未知"})
    return json.dumps({"city": city, **info}, ensure_ascii=False)


if __name__ == "__main__":
    # stdio 传输：通过标准输入/输出和 Client 通信
    # 适合 Client 和 Server 在同一台机器上的场景
    server.run(transport="stdio")

"""
MCP Client —— 连接 Server，发现工具，配合 LLM 完成任务
依赖：pip install "mcp[cli]" openai
"""

import asyncio
import json
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client
from openai import OpenAI


async def run():
    # ======== 第一步：连接 MCP Server ========
    server_params = StdioServerParameters(
        command="python",
        args=["mcp_server.py"],  # 启动 Server 的命令
    )

    # stdio_client 会启动一个子进程运行 Server，并通过 stdin/stdout 通信
    async with stdio_client(server_params) as (read_stream, write_stream):
        async with ClientSession(read_stream, write_stream) as session:
            # 握手初始化（交换协议版本、能力声明等）
            await session.initialize()

            # ======== 第二步：发现可用工具 ========
            tools_result = await session.list_tools()
            print(f"Server 提供了 {len(tools_result.tools)} 个工具：")
            for t in tools_result.tools:
                print(f"   - {t.name}: {t.description}")

            # 把 MCP 工具格式转换为 OpenAI Function Call 格式
            # 这一步是 MCP Client 的核心职责之一
            openai_tools = []
            for t in tools_result.tools:
                openai_tools.append({
                    "type": "function",
                    "function": {
                        "name": t.name,
                        "description": t.description or "",
                        "parameters": t.inputSchema,  # MCP 工具的参数已经是 JSON Schema
                    }
                })

            # ======== 第三步：与 LLM 交互 ========
            llm = OpenAI()
            messages = [
                {"role": "system", "content": "你是一个助手，可以查天气和做数学计算。"},
                {"role": "user", "content": "北京今天多少度？另外帮我算一下 42 × 38"}
            ]

            print("\n发送请求到 LLM...")
            response = llm.chat.completions.create(
                model="gpt-4o",
                messages=messages,
                tools=openai_tools,
                tool_choice="auto",
            )

            msg = response.choices[0].message
            if not msg.tool_calls:
                print(f"LLM 直接回复：{msg.content}")
                return

            print(f"LLM 要求调用 {len(msg.tool_calls)} 个工具")
            messages.append(msg.model_dump())

            # ======== 第四步：通过 MCP 协议调用工具 ========
            for call in msg.tool_calls:
                name = call.function.name
                args = json.loads(call.function.arguments)

                print(f"  通过 MCP 调用 {name}({args})")

                # 核心区别在这里：不是直接调本地函数，
                # 而是通过 MCP 协议发给 Server 执行
                #
                # session.call_tool() 是 MCP SDK 中 ClientSession 提供的方法，
                # 它会通过底层传输层（这里是 stdio）向 Server 发送一条
                # JSON-RPC 请求：{"method": "tools/call", "params": {"name": ..., "arguments": ...}}
                # Server 收到后执行对应的 @server.tool() 函数，把结果返回。
                # 我们不需要自己定义这个方法，SDK 已经封装好了。
                result = await session.call_tool(name, arguments=args)

                # MCP 返回的结果是 CallToolResult 对象，
                # 其中 content 是一个 Content 对象列表（通常是 TextContent）
                result_text = result.content[0].text
                print(f"  Server 返回：{result_text}")

                messages.append({
                    "role": "tool",
                    "tool_call_id": call.id,
                    "content": result_text,
                })

            # ======== 第五步：LLM 根据结果生成回复 ========
            print("\n发送工具结果到 LLM...")
            final = llm.chat.completions.create(model="gpt-4o", messages=messages)
            print(f"\n最终回复：{final.choices[0].message.content}")


if __name__ == "__main__":
    asyncio.run(run())

// Client → Server
{"jsonrpc": "2.0", "method": "tools/call", "params": {"name": "calculator", "arguments": {"expression": "42 * 38"}}, "id": 1}

// Server → Client
{"jsonrpc": "2.0", "result": {"content": [{"type": "text", "text": "{\"result\": 1596}"}]}, "id": 1}

# 可用工具

> **Skill name**: tool-assistant
> **Skill description**: 提供数学计算和天气查询能力。当用户需要做数学运算或查询天气时激活此技能。

你可以使用以下工具来完成任务。需要使用工具时，在回复中输出 action 代码块。
每次只输出一个 action 块，等待结果后再决定下一步。

---

## calculator - 数学计算器

**功能：** 计算数学表达式。当需要做任何数学运算时必须使用此工具，不要自己心算。

**调用格式：**

```action
{"tool": "calculator", "params": {"expression": "数学表达式"}}
```

**参数说明：**
- expression（必填）：数学表达式字符串，使用标准符号 + - * / ( )

**示例：**
用户问"3乘以7加2等于多少"，输出：

```action
{"tool": "calculator", "params": {"expression": "3 * 7 + 2"}}
```

---

## get_weather - 天气查询

**功能：** 查询城市的实时天气信息。

**调用格式：**

```action
{"tool": "get_weather", "params": {"city": "城市名"}}
```

**参数说明：**
- city（必填）：要查询的城市名称

**示例：**
用户问"上海天气怎么样"，输出：

```action
{"tool": "get_weather", "params": {"city": "上海"}}
```

---

## 重要规则

1. 需要计算时**必须**使用 calculator，不要自己算
2. 每次回复中**最多输出一个** action 块
3. 输出 action 块后**立即停止**，等待工具结果
4. 收到工具结果后，继续处理剩余任务或给出最终回答
5. 如果不需要使用工具，直接回复即可，不要输出 action 块

"""
方案三：Skills
依赖：pip install openai
特点：不需要模型支持 Function Call，任何 LLM 都能用
"""

import json
import re
from openai import OpenAI
from tools import TOOL_MAP


def load_skills_doc() -> str:
    """
    加载 Skills 说明书。
    生产环境应该从 skills_doc.md 文件读取：
        with open("skills_doc.md") as f:
            return f.read()
    这里为了示例自包含，直接写在代码中。
    注意：返回内容与前面的 skills_doc.md 模板保持一致，
    包含 Skill name 和 description 元数据。
    """
    return '''
# 可用工具

> **Skill name**: tool-assistant
> **Skill description**: 提供数学计算和天气查询能力。当用户需要做数学运算或查询天气时激活此技能。

你可以使用以下工具来完成任务。需要使用工具时，在回复中输出 action 代码块。
每次只输出一个 action 块，等待结果后再决定下一步。

---

## calculator - 数学计算器

**功能：** 计算数学表达式。当需要做任何数学运算时必须使用此工具，不要自己心算。

**调用格式：**

```action
{"tool": "calculator", "params": {"expression": "数学表达式"}}
```

**参数说明：**
- expression（必填）：数学表达式字符串，使用标准符号 + - * / ( )

**示例：**
用户问"3乘以7加2等于多少"，输出：

```action
{"tool": "calculator", "params": {"expression": "3 * 7 + 2"}}
```

---

## get_weather - 天气查询

**功能：** 查询城市的实时天气信息。

**调用格式：**

```action
{"tool": "get_weather", "params": {"city": "城市名"}}
```

**参数说明：**
- city（必填）：要查询的城市名称

**示例：**
用户问"上海天气怎么样"，输出：

```action
{"tool": "get_weather", "params": {"city": "上海"}}
```

---

## 重要规则

1. 需要计算时**必须**使用 calculator，不要自己算
2. 每次回复中**最多输出一个** action 块
3. 输出 action 块后**立即停止**，等待工具结果
4. 收到工具结果后，继续处理剩余任务或给出最终回答
5. 如果不需要使用工具，直接回复即可，不要输出 action 块
'''


def parse_action(text: str) -> dict | None:
    """
    从 LLM 的回复文本中解析 action 代码块。
    返回解析出的 dict，如果没有 action 块则返回 None。
    """
    # 匹配 ```action ... ``` 代码块
    pattern = r"```action\s*\n?(.*?)\n?```"
    match = re.search(pattern, text, re.DOTALL)
    if not match:
        return None

    raw = match.group(1).strip()
    try:
        action = json.loads(raw)
        # 基本校验：必须有 tool 和 params 字段
        if "tool" not in action or "params" not in action:
            print(f"  action 块缺少必要字段: {action}")
            return None
        return action
    except json.JSONDecodeError as e:
        print(f"  action 块 JSON 解析失败: {e}")
        print(f"  原始内容: {raw}")
        return None


def run():
    client = OpenAI()

    system_prompt = f"""你是一个助手，可以通过工具查天气和做数学计算。

{load_skills_doc()}
"""

    messages = [
        {"role": "system", "content": system_prompt},
        {"role": "user", "content": "北京今天多少度？另外帮我算一下 42 × 38"}
    ]

    MAX_ROUNDS = 10  # 安全限制，防止无限循环

    for round_num in range(1, MAX_ROUNDS + 1):
        print(f"\n{'='*50}")
        print(f"第 {round_num} 轮请求")

        # 普通的 Chat Completion 调用，注意没有 tools 参数
        response = client.chat.completions.create(
            model="gpt-4o",
            messages=messages,
        )

        reply = response.choices[0].message.content
        print("LLM 回复：")
        print(f"   {reply[:300]}{'...' if len(reply) > 300 else ''}")

        # 把回复加入对话历史
        messages.append({"role": "assistant", "content": reply})

        # 解析 action 块
        action = parse_action(reply)

        if action is None:
            # 没有 action 块 = LLM 认为任务已完成
            print(f"\n最终回复：{reply}")
            break

        # 执行工具
        tool_name = action["tool"]
        tool_params = action["params"]

        if tool_name not in TOOL_MAP:
            error_msg = f"未知工具: {tool_name}"
            print(f"  {error_msg}")
            messages.append({"role": "user", "content": f"工具调用错误：{error_msg}"})
            continue

        print(f"  执行 {tool_name}({tool_params})")
        result = TOOL_MAP[tool_name](**tool_params)
        print(f"  结果：{result}")

        # 将结果以 user 消息传回（Skills 模式没有专门的 tool 角色）
        messages.append({
            "role": "user",
            "content": f"工具 {tool_name} 执行结果：{result}\n\n请根据已有信息继续处理。"
        })

    print(f"\n共经历 {round_num} 轮对话")


if __name__ == "__main__":
    run()

# 实际项目中可能是这样的：

# 1. Skills 说明书告诉 LLM："处理金融数据时要特别小心，先查余额再转账"
#    （认知层：引导决策策略）

# 2. LLM 通过 Function Call 输出结构化的调用意图
#    （接口层：可靠的输出格式）

# 3. 应用通过 MCP 协议把请求发给远程的银行 API Server
#    （协议层：标准化的工具通信）

{"name": "delete_database", "arguments": {"confirm": true}}

"""
工单处理 MCP Server —— 提供 CRM 查询和计算工具
运行：python ticket_mcp_server.py
"""

from mcp.server.fastmcp import FastMCP

mcp = FastMCP("ticket-tools")


# 模拟 CRM 数据库
CUSTOMER_DB = {
    "ACME Corp": {
        "contract_level": "白金",
        "sla_response_hours": 4,
        "sla_resolve_hours": 24,
        "account_manager": "张伟",
        "open_tickets": 3,
        "monthly_revenue": 500000,
        "history_note": "上月有过2次数据库相关工单，均已解决"
    },
    "Beta Inc": {
        "contract_level": "黄金",
        "sla_response_hours": 8,
        "sla_resolve_hours": 48,
        "account_manager": "李娜",
        "open_tickets": 1,
        "monthly_revenue": 120000,
        "history_note": "历史工单较少，服务满意度高"
    },
}


@mcp.tool()
def query_customer(customer_name: str) -> str:
    """
    查询客户信息，返回合同级别、SLA 标准、客户经理、历史工单等。
    参数：customer_name - 客户名称
    """
    import json
    customer = CUSTOMER_DB.get(customer_name)
    if customer:
        return json.dumps(customer, ensure_ascii=False, indent=2)
    return json.dumps({"error": f"未找到客户: {customer_name}"}, ensure_ascii=False)


@mcp.tool()
def calculator(expression: str) -> str:
    """
    演示用：在受限环境中计算数学表达式，返回结果。
    参数：expression - 数学表达式，如 "4 * 60 - 135"
    """
    import json
    allowed = set("0123456789+-*/.() ")
    if not all(c in allowed for c in expression):
        return json.dumps({"error": "包含不允许的字符"}, ensure_ascii=False)
    try:
        # 这里只是为了演示流程而做的简化实现。
        # 生产环境仍应使用 AST 白名单或专门的安全求值器。
        result = eval(expression, {"__builtins__": {}}, {})
        return json.dumps({"expression": expression, "result": result}, ensure_ascii=False)
    except Exception as e:
        return json.dumps({"error": str(e)}, ensure_ascii=False)


if __name__ == "__main__":
    mcp.run(transport="stdio")

# 工单分级处理策略

> **Skill name**: ticket-triage
> **Skill description**: 智能工单分级处理助手。当用户提到"工单"、"故障"、"SLA"、"客户报障"等意图时激活。提供客户查询、SLA 计算和处理建议的一站式服务。

## 工作流程

收到工单处理需求后，严格按以下顺序执行：

### 步骤 1：查询客户信息
- 使用 `query_customer` 工具查询客户的合同级别、SLA 标准、历史工单
- 如果用户没有给出客户名称，先询问

### 步骤 2：计算 SLA 剩余时间
- 使用 `calculator` 工具计算
- 公式：SLA 要求时间（分钟） - 已用时间（分钟）
- 判断紧急程度：
  - **紧急**：剩余时间 < SLA 总时间的 25%（即将超期）
  - **警告**：剩余时间 < SLA 总时间的 50%
  - **正常**：剩余时间 >= SLA 总时间的 50%

### 步骤 3：生成处理建议
根据客户级别 + SLA 紧急程度，给出分级建议：

| 客户级别 | 紧急程度 | 建议 |
|---------|---------|------|
| 白金 | 紧急 | 立即升级至 P0，通知客户经理 + 技术总监，15分钟内响应 |
| 白金 | 警告 | 升级至 P1，通知客户经理，30分钟内响应 |
| 白金 | 正常 | P2 正常处理，但优先排队 |
| 黄金/白银 | 紧急 | 升级至 P1，通知客户经理 |
| 黄金/白银 | 警告 / 正常 | 按正常流程处理 |

### 回复格式
最终回复必须包含四个部分，用清晰的标题分隔：
1. **客户概况**（合同级别、月营收、历史情况）
2. **SLA 分析**（剩余时间、紧急程度判定）
3. **处理建议**（建议优先级、通知谁、响应时限）
4. **风险提示**（如有历史类似问题、客户情绪等）

"""
智能工单处理系统 —— 融合 Skills + Function Call + MCP
依赖：pip install "mcp[cli]" openai
"""

import asyncio
import json
from pathlib import Path
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client
from openai import OpenAI


# ======== Skills 管理：name/description 索引 + 按需加载 ========

SKILLS_REGISTRY = [
    {
        "name": "ticket-triage",
        "description": "智能工单分级处理助手。当用户提到工单、故障、SLA、客户报障等意图时激活。",
        "doc_path": "ticket_triage_skill.md",
    },
    # 未来可以加更多 Skill，比如：
    # {"name": "incident-postmortem", "description": "故障复盘助手...", "doc_path": "..."},
    # {"name": "capacity-planner", "description": "容量规划助手...", "doc_path": "..."},
]


def build_skills_index() -> str:
    """
    构建 Skills 索引文本（只有 name + description），常驻 System Prompt。
    这就是 LLM 的"目录页"——Token 开销很小。
    """
    lines = ["## 可用技能（Skills）", ""]
    for skill in SKILLS_REGISTRY:
        lines.append(f"- **{skill['name']}**: {skill['description']}")
    lines.append("")
    lines.append("当你判断用户意图匹配某个技能时，回复 `[LOAD_SKILL: 技能名]` 来加载它。")
    return "\n".join(lines)


def load_skill(skill_name: str) -> str | None:
    """
    按需加载 Skill 的完整文档。
    只有 LLM 判断需要时才调用，避免每次都注入所有文档。
    """
    for skill in SKILLS_REGISTRY:
        if skill["name"] == skill_name:
            path = Path(skill["doc_path"])
            if path.exists():
                return path.read_text(encoding="utf-8")
            else:
                return _get_embedded_skill(skill_name)
    return None


def _get_embedded_skill(name: str) -> str:
    """内嵌的 Skill 文档（示例用，生产环境应从文件读取）"""
    if name == "ticket-triage":
        return """
收到工单处理需求后，严格按以下顺序执行：
1. 使用 query_customer 工具查询客户合同级别、SLA 标准、历史工单
2. 使用 calculator 工具计算 SLA 剩余时间（分钟）
3. 根据客户级别 + SLA 紧急程度给出分级处理建议

紧急程度判定：
- 紧急：剩余 < 25% SLA 时间
- 警告：剩余 < 50% SLA 时间
- 正常：剩余 >= 50% SLA 时间

回复格式：客户概况、SLA 分析、处理建议、风险提示
"""
    return None


async def run():
    # ======== MCP 层：连接工具 Server ========
    server_params = StdioServerParameters(
        command="python", args=["ticket_mcp_server.py"]
    )

    async with stdio_client(server_params) as (read, write):
        async with ClientSession(read, write) as session:
            await session.initialize()

            # 从 MCP Server 发现可用工具
            tools_result = await session.list_tools()
            print(f"MCP: 发现 {len(tools_result.tools)} 个工具")

            # ======== Function Call 层：把 MCP 工具转为 OpenAI 格式 ========
            openai_tools = []
            for t in tools_result.tools:
                openai_tools.append({
                    "type": "function",
                    "function": {
                        "name": t.name,
                        "description": t.description or "",
                        "parameters": t.inputSchema,
                        "strict": True,
                    }
                })

            # ======== Skills 层：构建 System Prompt ========
            skills_index = build_skills_index()
            system_prompt = f"""你是企业客服系统的智能助手，拥有多种专业技能。

{skills_index}

当前已加载技能：（暂无）
"""

            llm = OpenAI()
            messages = [
                {"role": "system", "content": system_prompt},
                {"role": "user", "content": (
                    "客户 ACME Corp 报了一个生产环境数据库连接超时问题，"
                    "合同是白金级别，帮我查一下这个客户的信息，"
                    "算一下 SLA 还剩多少时间（4小时响应要求，工单创建于2小时15分钟前），"
                    "然后给我一个处理建议。"
                )}
            ]

            # ======== 主循环：Skills 匹配、Function Call 调用、MCP 执行 ========
            MAX_ROUNDS = 15
            skill_loaded = False

            for round_num in range(1, MAX_ROUNDS + 1):
                print(f"\n{'='*50}")
                print(f"第 {round_num} 轮")

                response = llm.chat.completions.create(
                    model="gpt-4o",
                    messages=messages,
                    tools=openai_tools if skill_loaded else None,
                    tool_choice="auto" if skill_loaded else None,
                )

                msg = response.choices[0].message

                # 情况 A：LLM 要求加载 Skill（Skills 层触发）
                if msg.content and "[LOAD_SKILL:" in msg.content:
                    import re
                    match = re.search(r"\[LOAD_SKILL:\s*(\S+?)\]", msg.content)
                    if match:
                        skill_name = match.group(1)
                        print(f"加载 Skill: {skill_name}")

                        skill_doc = load_skill(skill_name)
                        if skill_doc:
                            messages.append({"role": "assistant", "content": msg.content})
                            messages.append({
                                "role": "user",
                                "content": f"[SKILL_LOADED: {skill_name}]\n\n{skill_doc}\n\n请根据以上技能文档处理用户的请求。"
                            })
                            messages[0]["content"] = system_prompt.replace(
                                "当前已加载技能：（暂无）",
                                f"当前已加载技能：{skill_name}"
                            )
                            skill_loaded = True
                            continue

                # 情况 B：LLM 通过 Function Call 调用工具（从接口层进入协议层）
                if msg.tool_calls:
                    print(f"Function Call: {len(msg.tool_calls)} 个工具调用")
                    messages.append(msg.model_dump())

                    for call in msg.tool_calls:
                        name = call.function.name
                        args = json.loads(call.function.arguments)
                        print(f"   MCP 调用 {name}({args})")

                        result = await session.call_tool(name, arguments=args)
                        result_text = result.content[0].text
                        print(f"   结果：{result_text}")

                        messages.append({
                            "role": "tool",
                            "tool_call_id": call.id,
                            "content": result_text,
                        })
                    continue

                # 情况 C：LLM 给出最终回复
                if msg.content:
                    print(f"\n最终回复：\n{msg.content}")
                    break

            print(f"\n共 {round_num} 轮，三层协作完成任务")


if __name__ == "__main__":
    asyncio.run(run())