uncloseai.com/languages/cpp/boost-beast/uncloseai.cpp

/*
 * UncloseAI C++ Library
 * OpenAI-compatible API client with streaming support
 * Compatible with vLLM, Ollama, and OpenAI-compatible endpoints
 */

#include <iostream>
#include <string>
#include <vector>
#include <memory>
#include <fstream>
#include <sstream>
#include <cstdlib>
#include <cstring>
#include <curl/curl.h>

// Model info structure
struct ModelInfo {
    std::string id;
    std::string endpoint;
    int max_tokens;
};

// UncloseAI Client class
class UncloseAIClient {
private:
    std::vector<ModelInfo> models;
    std::vector<std::string> tts_endpoints;
    int timeout;

public:
    UncloseAIClient(int timeout_sec = 30) : timeout(timeout_sec) {}

    std::vector<ModelInfo> get_models() const { return models; }
    std::vector<std::string> get_tts_endpoints() const { return tts_endpoints; }

    // Initialize client with model discovery
    void init();

    // Non-streaming chat
    int chat(int model_idx, const std::string& prompt, std::string& response);

    // Streaming chat
    int chat_stream(int model_idx, const std::string& prompt);

    // Text-to-speech
    int tts(const std::string& text, const std::string& voice, const std::string& output_file);

private:
    void discover_models_from_endpoint(const std::string& endpoint);
};

// Memory callback struct for capturing response data
struct MemoryStruct {
    std::string data;
};

// Callback function to capture response data
static size_t WriteMemoryCallback(void *contents, size_t size, size_t nmemb, void *userp) {
    size_t realsize = size * nmemb;
    MemoryStruct *mem = static_cast<MemoryStruct*>(userp);

    mem->data.append(static_cast<char*>(contents), realsize);

    return realsize;
}

// Helper to extract model IDs from JSON (simple string search)
void extract_model_ids(const std::string& json, const std::string& endpoint, std::vector<ModelInfo>& models) {
    size_t pos = 0;
    std::string id_marker = "\"id\":\"";

    while((pos = json.find(id_marker, pos)) != std::string::npos) {
        pos += id_marker.length();
        size_t end = json.find("\"", pos);
        if(end != std::string::npos) {
            std::string model_id = json.substr(pos, end - pos);

            // Filter out modelperm-* entries
            if(model_id.find("modelperm-") == 0) {
                pos = end + 1;
                continue;
            }

            ModelInfo info;
            info.id = model_id;
            info.endpoint = endpoint;
            info.max_tokens = 8192;
            models.push_back(info);
        }
        pos = end + 1;
    }
}

void UncloseAIClient::discover_models_from_endpoint(const std::string& endpoint) {
    CURL *curl = curl_easy_init();
    if(!curl) return;

    std::string url = endpoint + "/models";
    MemoryStruct chunk;

    curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteMemoryCallback);
    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &chunk);
    curl_easy_setopt(curl, CURLOPT_TIMEOUT, 10L);

    CURLcode res = curl_easy_perform(curl);

    if(res == CURLE_OK) {
        extract_model_ids(chunk.data, endpoint, models);
    }

    curl_easy_cleanup(curl);
}

void UncloseAIClient::init() {
    std::cout << "Initializing UncloseAI client..." << std::endl;

    // Discover chat/code models
    for(int i = 1; i < 10000; i++) {
        std::string var_name = "MODEL_ENDPOINT_" + std::to_string(i);
        const char* endpoint = std::getenv(var_name.c_str());
        if(!endpoint) break;

        std::cout << "Endpoint " << i << ": " << endpoint << std::endl;
        discover_models_from_endpoint(endpoint);
    }

    // Discover TTS endpoints
    for(int i = 1; i < 10000; i++) {
        std::string var_name = "TTS_ENDPOINT_" + std::to_string(i);
        const char* endpoint = std::getenv(var_name.c_str());
        if(!endpoint) break;
        tts_endpoints.push_back(endpoint);
    }

    std::cout << "Discovered " << models.size() << " models, "
              << tts_endpoints.size() << " TTS endpoints\n" << std::endl;
}

int UncloseAIClient::chat(int model_idx, const std::string& prompt, std::string& response) {
    if(model_idx >= static_cast<int>(models.size())) return -1;

    ModelInfo model = models[model_idx];
    std::string url = model.endpoint + "/chat/completions";

    std::string json = "{\"model\":\"" + model.id + "\","
                      "\"messages\":[{\"role\":\"user\",\"content\":\"" + prompt + "\"}],"
                      "\"stream\":false,\"max_tokens\":100,\"temperature\":0.7}";

    CURL *curl = curl_easy_init();
    if(!curl) return -1;

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

    MemoryStruct chunk;

    curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
    curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
    curl_easy_setopt(curl, CURLOPT_POSTFIELDS, json.c_str());
    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteMemoryCallback);
    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &chunk);
    curl_easy_setopt(curl, CURLOPT_TIMEOUT, timeout);

    CURLcode res = curl_easy_perform(curl);

    curl_slist_free_all(headers);
    curl_easy_cleanup(curl);

    if(res == CURLE_OK) {
        response = chunk.data;
        return 0;
    }
    return -1;
}

// Streaming context
struct StreamContext {
    std::string buffer;
};

static size_t StreamWriteCallback(void *contents, size_t size, size_t nmemb, void *userp) {
    size_t realsize = size * nmemb;
    StreamContext *ctx = static_cast<StreamContext*>(userp);

    std::string data(static_cast<char*>(contents), realsize);
    ctx->buffer += data;

    size_t pos;
    while((pos = ctx->buffer.find('\n')) != std::string::npos) {
        std::string line = ctx->buffer.substr(0, pos);
        ctx->buffer.erase(0, pos + 1);

        if(line.find("data: ") == 0) {
            std::string json_data = line.substr(6);
            if(json_data == "[DONE]") return 0;

            size_t content_pos = json_data.find("\"content\":\"");
            if(content_pos != std::string::npos) {
                content_pos += 11;
                size_t end_pos = json_data.find("\"", content_pos);
                if(end_pos != std::string::npos) {
                    std::string content = json_data.substr(content_pos, end_pos - content_pos);
                    if(!content.empty()) {
                        std::cout << content << std::flush;
                    }
                }
            }
        }
    }

    return realsize;
}

int UncloseAIClient::chat_stream(int model_idx, const std::string& prompt) {
    if(model_idx >= static_cast<int>(models.size())) return -1;

    ModelInfo model = models[model_idx];
    std::string url = model.endpoint + "/chat/completions";

    std::string json = "{\"model\":\"" + model.id + "\","
                      "\"messages\":[{\"role\":\"user\",\"content\":\"" + prompt + "\"}],"
                      "\"stream\":true,\"max_tokens\":500,\"temperature\":0.7}";

    CURL *curl = curl_easy_init();
    if(!curl) return -1;

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

    StreamContext ctx;

    curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
    curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
    curl_easy_setopt(curl, CURLOPT_POSTFIELDS, json.c_str());
    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, StreamWriteCallback);
    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &ctx);
    curl_easy_setopt(curl, CURLOPT_TIMEOUT, timeout);

    CURLcode res = curl_easy_perform(curl);

    curl_slist_free_all(headers);
    curl_easy_cleanup(curl);

    return (res == CURLE_OK) ? 0 : -1;
}

int UncloseAIClient::tts(const std::string& text, const std::string& voice, const std::string& output_file) {
    if(tts_endpoints.empty()) return -1;

    std::string url = tts_endpoints[0] + "/audio/speech";
    std::string json = "{\"model\":\"tts-1\",\"voice\":\"" + voice + "\",\"input\":\"" + text + "\"}";

    CURL *curl = curl_easy_init();
    if(!curl) return -1;

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

    MemoryStruct chunk;

    curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
    curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
    curl_easy_setopt(curl, CURLOPT_POSTFIELDS, json.c_str());
    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteMemoryCallback);
    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &chunk);
    curl_easy_setopt(curl, CURLOPT_TIMEOUT, timeout);

    CURLcode res = curl_easy_perform(curl);

    curl_slist_free_all(headers);
    curl_easy_cleanup(curl);

    if(res == CURLE_OK) {
        std::ofstream output(output_file, std::ios::binary);
        if(output.is_open()) {
            output.write(chunk.data.c_str(), chunk.data.size());
            output.close();
            return 0;
        }
    }

    return -1;
}

// Demo program showing library usage
int main() {
    std::cout << "=== UncloseAI C++ Client (with Streaming) ===\n" << std::endl;

    curl_global_init(CURL_GLOBAL_ALL);

    // Initialize client
    UncloseAIClient client(30);
    client.init();

    if(client.get_models().empty()) {
        std::cout << "ERROR: No models discovered" << std::endl;
        curl_global_cleanup();
        return 1;
    }

    // Non-streaming chat example
    std::cout << "=== Non-Streaming Chat ===" << std::endl;
    std::cout << "Model: " << client.get_models()[0].id << std::endl;

    std::string response;
    if(client.chat(0, "Explain quantum computing in one sentence", response) == 0) {
        std::cout << "Response received (" << response.size() << " bytes)" << std::endl;
        std::cout << "(Full response requires JSON parsing library)" << std::endl;
    } else {
        std::cout << "Request failed" << std::endl;
    }

    std::cout << std::endl;

    // Streaming chat example
    int model_idx = client.get_models().size() >= 2 ? 1 : 0;
    std::cout << "=== Streaming Chat ===" << std::endl;
    std::cout << "Model: " << client.get_models()[model_idx].id << std::endl;
    std::cout << "Response: ";

    if(client.chat_stream(model_idx, "Write a hello world program in C++") != 0) {
        std::cout << std::endl << "Streaming request failed" << std::endl;
    }

    std::cout << "\n" << std::endl;

    // TTS example
    if(!client.get_tts_endpoints().empty()) {
        std::cout << "=== TTS Speech Generation ===" << std::endl;
        std::cout << "Model: tts-1" << std::endl;

        if(client.tts("Hello from UncloseAI C++ client!", "alloy", "/tmp/speech.mp3") == 0) {
            std::cout << "Audio saved to /tmp/speech.mp3" << std::endl;
        } else {
            std::cout << "TTS failed" << std::endl;
        }
    }

    std::cout << "\n=== Examples Complete ===" << std::endl;

    curl_global_cleanup();
    return 0;
}