Method worker_loop

server/src/server/http_server.cpp:1804–3326

            "HTTP/1.1 200 OK\r\n"
            "Content-Type: text/event-stream\r\n"
            "Cache-Control: no-cache\r\n"
            "Connection: keep-alive\r\n"
            "Access-Control-Allow-Origin: *\r\n"
            "\r\n";
        if (!send_all(fd, headers, std::strlen(headers))) {
            socket_close(fd);
            return;
        }
        // Send initial state immediately.
        std::string initial = status_.to_sse_event();
        send_all(fd, initial.data(), initial.size());
        // Register for future broadcasts. The fd is NOT closed here — it stays
        // open until the client disconnects (detected on next broadcast send).
        {
            std::lock_guard<std::mutex> lk(sse_mu_);
            sse_fds_.push_back(fd);
        }
        return;  // Do NOT close fd — it's now owned by the SSE broadcast loop.
    }

    // Models endpoint (including the existing Codex discovery schema).
    if (hr.method == "GET" && hr.path == "/v1/models") {
        const bool codex_schema = hr.query.find("client_version") != std::string::npos;
        json response = model_list(config_, codex_schema);
        if (!models_.empty()) {
            const char * key = codex_schema ? "models" : "data";
            for (size_t i = 0; i < models_.size(); ++i) {
                const auto & cfg = models_[i].server->config_;
                if (i != 0) response[key].push_back(model_list(cfg, codex_schema)[key][0]);
            }
        }
        send_response(fd, 200, "application/json", response.dump() + "\n");
        socket_close(fd);
        return;
    }

    // Route POST endpoints.
    if (!route_request(fd, hr)) {
        send_error(fd, 404, "unknown endpoint");
    }
    socket_close(fd);
}

// Endpoint structure is parsed once by the listener. Model defaults, templates
// and token IDs are resolved only by the selected model's handler.
bool HttpServer::route_model_request(SocketHandle fd, ParsedRequest & req,
                                     bool count_only) {
    json & body = req.raw_body;
    const std::string requested = body.value("model", std::string());
    const bool unnamed = requested.empty() || requested == "auto";
    if (count_only && unnamed) {
        send_error(fd, 400, "token counting requires an explicit model name");
        return true;
    }
    // Generation always follows operator priority. Only token counting needs
    // an explicit tokenizer, since no generating model has been selected yet.
    const bool automatic = !count_only;