Step 4: 多轮对话 —— 让 Agent 记得住（会话级上下文）¶

class SessionManager {
public:
    std::string generate_session_id() {
        static std::random_device rd;
        static std::mt19937 gen(rd());
        static std::uniform_int_distribution<> dis(0, 15);

        const char* hex = "0123456789abcdef";
        std::string id;
        for (int i = 0; i < 32; ++i) {
            id += hex[dis(gen)];
        }
        return id;  // 256-bit，如 "a3f7b2d8e9c1..."
    }
};

struct ChatContext {
    std::string session_id;
    std::string last_intent;     // 上一次的意图（如"weather_query"）
    std::string last_topic;      // 上一次的话题（如"北京"）
    std::vector<std::pair<std::string, std::string>> history;  // 对话历史
    std::chrono::steady_clock::time_point last_time;
    int message_count = 0;

    // 检查上下文是否有效（30秒内）
    bool is_valid() const {
        auto elapsed = std::chrono::duration_cast<std::chrono::seconds>(
            std::chrono::steady_clock::now() - last_time).count();
        return elapsed < 30;
    }
};

class SessionManager {
private:
    std::map<std::string, std::shared_ptr<ChatContext>> sessions_;
    mutable std::mutex mutex_;

public:
    std::shared_ptr<ChatContext> get_or_create_session(
        const std::string& session_id) {
        std::lock_guard<std::mutex> lock(mutex_);

        auto it = sessions_.find(session_id);
        if (it != sessions_.end()) {
            it->second->last_time = std::chrono::steady_clock::now();
            return it->second;
        }

        // 创建新 Session
        auto ctx = std::make_shared<ChatContext>();
        ctx->session_id = session_id;
        sessions_[session_id] = ctx;
        return ctx;
    }

    // 清理过期 Session（5分钟未活动）
    void cleanup_expired() {
        std::lock_guard<std::mutex> lock(mutex_);
        auto now = std::chrono::steady_clock::now();

        for (auto it = sessions_.begin(); it != sessions_.end();) {
            auto elapsed = std::chrono::duration_cast<std::chrono::seconds>(
                now - it->second->last_time).count();
            if (elapsed > 300) {
                it = sessions_.erase(it);
            } else {
                ++it;
            }
        }
    }
};

class ChatEngine {
public:
    std::string process(const std::string& input, ChatContext& ctx) {
        ctx.message_count++;
        ctx.history.push_back({"user", input});

        // 1. 检查是否是上下文相关的提问
        if (is_contextual_question(input, ctx)) {
            std::string reply = handle_contextual(input, ctx);
            ctx.history.push_back({"ai", reply});
            return reply;
        }

        // 2. 规则匹配（Step 3 的逻辑）
        for (const auto& rule : rules_) {
            if (std::regex_search(input, rule.pattern)) {
                ctx.last_intent = rule.intent;
                ctx.last_topic = extract_topic(input, rule.intent);
                ctx.last_time = std::chrono::steady_clock::now();
                std::string reply = rule.response(input);
                ctx.history.push_back({"ai", reply});
                return reply;
            }
        }

        return "我不理解你的问题，可以试试：你好、时间、北京天气、那上海呢";
    }

private:
    // 判断是否是上下文相关的提问
    bool is_contextual_question(const std::string& input, 
                                 const ChatContext& ctx) {
        // 包含代词：那、它、这个、那里
        bool has_pronoun = std::regex_search(input,
            std::regex("那|它|这个|那里", std::regex::icase));

        // 且上下文有效（30秒内，有上一个意图）
        return has_pronoun && ctx.is_valid() && !ctx.last_intent.empty();
    }

    std::string handle_contextual(const std::string& input, 
                                   ChatContext& ctx) {
        if (ctx.last_intent == "weather_query") {
            std::string reply = get_weather_for_city(input);
            reply += "\n💡 (我理解了你想比较 " + ctx.last_topic + 
                    " 和其他城市的天气)";
            ctx.last_topic = extract_topic(input, "weather_query");
            return reply;
        }
        return "能再说清楚一点吗？或者重新开始一个新话题。";
    }
};

// 请求
POST /chat HTTP/1.1
Content-Type: application/json

{
    "message": "北京天气",
    "session_id": ""  // 首次对话为空，后续带上
}

// 响应
HTTP/1.1 200 OK
Content-Type: application/json

{
    "session_id": "a3f7b2d8e9c1...",  // 首次返回，后续复用
    "reply": "🌤️ 北京今天晴天，25°C",
    "message_count": 1,
    "has_context": true
}

HttpResponse handle_chat(const HttpRequest& req) {
    try {
        json::value jv = json::parse(req.body);
        std::string message = std::string(jv.as_object()["message"].as_string());

        // 获取或创建 Session
        std::string session_id;
        if (jv.as_object().contains("session_id")) {
            session_id = std::string(jv.as_object()["session_id"].as_string());
        } else {
            session_id = session_manager_.generate_session_id();
        }

        auto ctx = session_manager_.get_or_create_session(session_id);
        std::string reply = ai_.process(message, *ctx);

        json::object result;
        result["session_id"] = session_id;
        result["reply"] = reply;
        result["message_count"] = ctx->message_count;
        result["has_context"] = !ctx->last_intent.empty();

        HttpResponse resp;
        resp.body = json::serialize(result);
        return resp;

    } catch (const std::exception& e) {
        HttpResponse resp;
        resp.status_code = 400;
        resp.body = std::string(R"({"error": ")") + e.what() + """}";
        return resp;
    }
}

// 记住用户信息（仅本次会话有效）
用户: 我叫小明
Agent: 你好小明，我会在这轮对话中记住你的名字

// 后续对话
用户: 我叫什么？
Agent: 你叫小明呀！（从当前会话上下文中读取）
// ⚠️ 注意：关闭对话后再次打开，Agent 会忘记！

// 订机票场景
用户: 我要订机票
Agent: 请问从哪里出发？
（context.intent = "book_flight", context.step = 1）

用户: 北京
Agent: 请问目的地是哪里？
（context.slots["from"] = "北京", context.step = 2）

用户: 上海
Agent: 请问什么日期？
（context.slots["to"] = "上海", context.step = 3）

用户: 明天
Agent: 好的，为您查询北京到上海明天的机票...
（context.slots["date"] = "明天"，执行查询）