Step 5: Agent 核心 —— LLM 接入与工具调用¶

// 请求结构
struct ChatRequest {
    std::string model = "gpt-4";  // 模型名称
    std::vector<Message> messages;  // 对话历史
    std::vector<Tool> tools;        // 可用工具（可选）
    float temperature = 0.7;         // 随机性（0-2）
    int max_tokens = 2000;          // 最大输出长度
};

struct Message {
    std::string role;      // system / user / assistant / tool
    std::string content;   // 内容
    std::string name;      // tool 调用时的工具名
};

class LLMClient {
public:
    LLMClient(const std::string& api_key) : api_key_(api_key) {}

    bool is_configured() const {
        return !api_key_.empty();
    }

    // 调用 LLM 获取回复
    std::string complete(const std::vector<std::pair<std::string, std::string>>& messages) {
        // 实际项目中这里应该调用 OpenAI API
        // 简化版：模拟 LLM 响应
        return simulate_llm_response(messages);
    }

private:
    std::string api_key_;

    std::string simulate_llm_response(
        const std::vector<std::pair<std::string, std::string>>& messages) {

        // 获取最后一条用户消息
        std::string last_message;
        for (auto it = messages.rbegin(); it != messages.rend(); ++it) {
            if (it->first == "user") {
                last_message = it->second;
                break;
            }
        }

        // 模拟 LLM 理解（实际 LLM 会基于语义理解）
        if (last_message.find("你好") != std::string::npos ||
            last_message.find("hello") != std::string::npos) {
            return "你好！我是基于 LLM 的 AI 助手。与 Step 4 的规则 AI 不同，我能理解你的语义，而不只是匹配关键词。";
        }

        if (last_message.find("天气") != std::string::npos) {
            return "我可以通过调用工具来查询天气。与 Step 4 不同的是，我不需要预定义规则，而是能理解你想知道天气信息。\n\n（注意：真正的天气查询需要工具支持，我们将在后续步骤添加）";
        }

        if (last_message.find("区别") != std::string::npos ||
            last_message.find("不同") != std::string::npos) {
            return "Step 4 vs Step 5 的区别：\n"
                   "- Step 4: 规则匹配，只能处理预设模式\n"
                   "- Step 5: LLM 理解，能处理任意自然语言\n\n"
                   "比如你说'今天适合出门吗'，规则 AI 无法理解，"
                   "但 LLM 能理解你在问天气/时间相关的问题。";
        }

        // 通用回复
        return "我理解你想说：\"" + last_message + "\"\n\n"
               "作为 LLM，我能理解你的语义，而不只是匹配关键词。";
    }
};

struct Tool {
    std::string name;           // 工具名称
    std::string description;    // 功能描述（LLM 用）
    json parameters;            // 参数 JSON Schema
    std::function<json(const json&)> execute;  // 执行函数
};

// 天气工具示例
Tool weather_tool = {
    .name = "get_weather",
    .description = "获取指定城市的当前天气信息",
    .parameters = {
        {"type", "object"},
        {"properties", {
            {"location", {
                {"type", "string"},
                {"description", "城市名称，如北京、上海"}
            }},
            {"date", {
                {"type", "string"},
                {"description", "日期，如今天、明天"}
            }}
        }},
        {"required", {"location"}}
    },
    .execute = [](const json& params) -> json {
        std::string location = params.value("location", "");
        // 实际调用天气 API
        return {
            {"location", location},
            {"temperature", 25},
            {"condition", "晴朗"}
        };
    }
};

class Agent {
public:
    Agent(LLMClient& llm) : llm_(llm) {}

    void register_tool(const Tool& tool) {
        tools_[tool.name] = tool;
    }

    // 处理用户输入
    template<typename Callback>
    void process(const std::string& user_input, Callback callback) {
        // 1. 构建系统提示
        std::vector<Message> messages = {
            {"system", build_system_prompt()},
            {"user", user_input}
        };

        // 2. 调用 LLM
        call_llm(messages, callback);
    }

private:
    void call_llm(std::vector<Message> messages, auto callback) {
        llm_.chat(messages, [this, messages, callback](auto ec, std::string reply) {
            if (ec) {
                callback("抱歉，服务暂时不可用");
                return;
            }

            // 3. 检查是否需要调用工具
            // LLM 可能返回类似：{"tool": "get_weather", "arguments": {...}}
            auto tool_call = parse_tool_call(reply);

            if (tool_call) {
                // 4. 执行工具
                std::string tool_name = tool_call->first;
                json arguments = tool_call->second;

                if (tools_.count(tool_name)) {
                    json result = tools_[tool_name].execute(arguments);

                    // 5. 将工具结果加入对话历史
                    messages.push_back({"assistant", reply});
                    messages.push_back({
                        "tool", 
                        result.dump(),
                        tool_name
                    });

                    // 6. 再次调用 LLM，让它基于工具结果生成回复
                    call_llm(messages, callback);
                } else {
                    callback("抱歉，我没有这个工具");
                }
            } else {
                // 直接返回 LLM 的回复
                callback(reply);
            }
        });
    }

    std::string build_system_prompt() {
        std::string prompt = 
            "你是一个智能助手。你可以使用以下工具：\n\n";

        for (const auto& [name, tool] : tools_) {
            prompt += "工具: " + name + "\n";
            prompt += "描述: " + tool.description + "\n";
            prompt += "参数: " + tool.parameters.dump() + "\n\n";
        }

        prompt += "如果需要使用工具，请按以下格式回复：\n";
        prompt += "TOOL_CALL: {\"tool\": \"工具名\", \"arguments\": {...}}\n";

        return prompt;
    }

    LLMClient& llm_;
    std::map<std::string, Tool> tools_;
};

agent.register_tool(weather_tool);
agent.register_tool(calculator_tool);
// ... 每个工具都要手动注册

.execute = [](const json& params) {
    std::string cmd = params["command"];
    system(cmd.c_str());  // 危险！任意代码执行
};