A Free Model Endpoint Returned 200 With an Empty Body. The Fix Was a Lease, Not a Retry.

#include <curl/curl.h>
#include <nlohmann/json.hpp>
#include <chrono>
#include <cstdlib>
#include <iostream>
#include <string>
#include <utility>

using json = nlohmann::json;

struct Lease {
    std::chrono::milliseconds connect_timeout{2500};
    std::chrono::milliseconds total_timeout{9000};
    size_t max_response_bytes = 4096;
};

size_t bounded_write(char *ptr, size_t size, size_t nmemb, void *userdata) {
    auto *state = static_cast<std::pair<std::string*, size_t>*>(userdata);
    size_t bytes = size * nmemb;
    if (!state || !state->first) return 0;
    if (state->first->size() + bytes > state->second) return 0;
    state->first->append(ptr, bytes);
    return bytes;
}

enum class Outcome { Accepted, Empty, SchemaViolation, TransportError };

Outcome parse_response(const std::string& body) {
    if (body.empty()) return Outcome::Empty;

    try {
        auto doc = json::parse(body);
        if (!doc.contains("choices") || !doc["choices"].is_array() || doc["choices"].empty()) {
            return Outcome::SchemaViolation;
        }

        const auto& first = doc["choices"][0];
        if (!first.contains("message") || !first["message"].is_object()) {
            return Outcome::SchemaViolation;
        }

        const auto& message = first["message"];
        if (!message.contains("content")) return Outcome::SchemaViolation;

        const auto content = message["content"].get<std::string>();
        if (content.empty()) return Outcome::Empty;

        return Outcome::Accepted;
    } catch (const json::exception&) {
        return Outcome::SchemaViolation;
    }
}

Outcome query_endpoint(const std::string& url,
                       const std::string& prompt,
                       const Lease& lease,
                       std::string& out_content) {
    CURL* curl = curl_easy_init();
    if (!curl) return Outcome::TransportError;

    json req = {{"prompt", prompt}, {"max_tokens", 128}};
    std::string req_body = req.dump();
    std::string response;
    auto state = std::make_pair(&response, lease.max_response_bytes);

    struct curl_slist* headers = nullptr;
    headers = curl_slist_append(headers, "Content-Type: application/json");

    curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
    curl_easy_setopt(curl, CURLOPT_POST, 1L);
    curl_easy_setopt(curl, CURLOPT_POSTFIELDS, req_body.c_str());
    curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, bounded_write);
    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &state);
    curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT_MS, static_cast<long>(lease.connect_timeout.count()));
    curl_easy_setopt(curl, CURLOPT_TIMEOUT_MS, static_cast<long>(lease.total_timeout.count()));
    curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1L);

    CURLcode res = curl_easy_perform(curl);
    long http_code = 0;
    if (res == CURLE_OK) {
        curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &http_code);
    }

    curl_slist_free_all(headers);
    curl_easy_cleanup(curl);

    if (res != CURLE_OK) return Outcome::TransportError;
    if (http_code < 200 || http_code >= 300) return Outcome::TransportError;

    Outcome result = parse_response(response);
    if (result == Outcome::Accepted) {
        auto doc = json::parse(response);
        out_content = doc["choices"][0]["message"]["content"].get<std::string>();
    }

    return result;
}

int main(int argc, char** argv) {
    if (argc < 2) return 2;
    std::string prompt = argv[1];

    const char* url = std::getenv("FREE_MODEL_URL");
    if (!url) return 2;

    Lease lease;
    std::string content;
    Outcome result = query_endpoint(url, prompt, lease, content);

    switch (result) {
        case Outcome::Accepted:
            std::cout << content << std::endl;
            return 0;
        case Outcome::Empty:
            std::cerr << "lease outcome: empty 200" << std::endl;
            std::cout << "severity=unknown; owner=oncall" << std::endl;
            return 1;
        case Outcome::SchemaViolation:
            std::cerr << "lease outcome: schema violation" << std::endl;
            std::cout << "severity=unknown; owner=oncall" << std::endl;
            return 1;
        case Outcome::TransportError:
            std::cerr << "lease outcome: transport error" << std::endl;
            std::cout << "severity=unknown; owner=oncall" << std::endl;
            return 1;
    }

    return 1;
}

#!/usr/bin/env bash
set -euo pipefail

ulimit -v 262144
timeout 20s ./triage_client "$1" > result.txt 2> error.log
status=$?

if [ "$status" -ne 0 ]; then
  echo "severity=unknown; owner=oncall" > result.txt
fi