remove provider aibn (#49)

Remove provider aibn

bot_microservice/constants.py

@@ -49,7 +49,6 @@ class ChatGptModelsEnum(StrEnum):
     gpt_3_5_turbo_stream_CodeLinkAva = "gpt-3.5-turbo-stream-CodeLinkAva"
     gpt_4_stream_ChatBase = "gpt-4-stream-ChatBase"
     gpt_3_5_turbo_stream_GptGo = "gpt-3.5-turbo-stream-GptGo"
-    gpt_3_5_turbo_stream_Aibn = "gpt-3.5-turbo-stream-Aibn"
     gpt_3_5_turbo_stream_FreeGpt = "gpt-3.5-turbo-stream-FreeGpt"
     gpt_3_5_turbo_stream_Cromicle = "gpt-3.5-turbo-stream-Cromicle"
     gpt_4_stream_Chatgpt4Online = "gpt-4-stream-Chatgpt4Online"
@@ -61,6 +60,7 @@ class ChatGptModelsEnum(StrEnum):
     gpt_3_5_turbo_stream_GeekGpt = "gpt-3.5-turbo-stream-GeekGpt"
     gpt_3_5_turbo_stream_gptforlove = "gpt-3.5-turbo-stream-gptforlove"
     gpt_3_5_turbo_stream_Vercel = "gpt-3.5-turbo-stream-Vercel"
+    gpt_3_5_turbo_stream_aivvm = "gpt-3.5-turbo-stream-aivvm"
 
     @classmethod
     def values(cls) -> set[str]:

chatgpt_microservice/README.md

@@ -75,8 +75,8 @@ docker run --rm -p 8858:8858 -it --name freegpt -e CHAT_PATH=/chat -e PROVIDERS=
 docker run --rm -p 8858:8858 -it --name freegpt -e IP_WHITE_LIST="[\"127.0.0.1\",\"192.168.1.1\"]" fantasypeak/freegpt:latest
 ```
 
-### Start the Zeus Service
+### Start the Zeus Service [optional]
-Zeus is a cpp-freegpt-webui auxiliary service, because some provider needs to perform specific operations such as get cookies and refreshing web pages etc.
+This is not necessary, Zeus is a cpp-freegpt-webui auxiliary service, because some provider needs to perform specific operations such as get cookies and refreshing web pages etc.
 If you need to use these specific providers, you need to start it(Zeus Docker)
 ```
 docker pull fantasypeak/freegpt-zeus:latest
@@ -85,6 +85,17 @@ docker pull fantasypeak/freegpt:latest
 docker run --rm --net=host -it --name freegpt fantasypeak/freegpt:latest
 ```
 
+### Start the flaresolverr docker [optional]
+This is not necessary, The some provider(aivvm) is enabled Cloudflare challenges, so we need use flaresolverr to solve it.
+```
+docker run -d \
+  --name=flaresolverr \
+  -p 8191:8191 \
+  -e LOG_LEVEL=info \
+  --restart unless-stopped \
+  ghcr.io/flaresolverr/flaresolverr:latest
+```
+
 ### Call OpenAi Api
 ```
 // It supports calling OpenAI's API, but need set API_KEY

chatgpt_microservice/client/js/chat.js

@@ -79,7 +79,7 @@ const ask_gpt = async (message) => {
                 <i class="fa fa-trash trash-icon" onclick="deleteMessage('${token}')"></i>
             </div>
         `;
-        console.log(message_box.innerHTML)
+        // console.log(message_box.innerHTML)
         message_box.scrollTop = message_box.scrollHeight;
         window.scrollTo(0, 0);
         await new Promise((r) => setTimeout(r, 500));
@@ -172,7 +172,7 @@ const ask_gpt = async (message) => {
 
         await load_conversations(20, 0);
 
-        console.log(e);
+        // console.log(e);
 
         let cursorDiv = document.getElementById(`cursor`);
         if (cursorDiv) cursorDiv.parentNode.removeChild(cursorDiv);
@@ -273,7 +273,7 @@ const load_conversation = async (conversation_id) => {
     let conversation = await JSON.parse(
         localStorage.getItem(`conversation:${conversation_id}`)
     );
-    console.log(conversation, conversation_id);
+    // console.log(conversation, conversation_id);
 
     for (item of conversation.items) {
         message_box.innerHTML += `
@@ -321,8 +321,8 @@ const get_conversation = async (conversation_id) => {
     let result = conversation.items.slice(-4)
     for (var i = 0; i < result.length; i++) {
         delete result[i].token;
-        console.log(result[i]);
+        // console.log(result[i]);
-        console.log(result[i]);
+        // console.log(result[i]);
     }
     return result;
 };
@@ -592,15 +592,15 @@ const observer = new MutationObserver((mutationsList) => {
 observer.observe(message_input, { attributes: true });
 
 function deleteMessage(token) {
-    console.log(token)
+    // console.log(token)
     const messageDivUser = document.getElementById(`user_${token}`)
     const messageDivGpt = document.getElementById(`gpt_${token}`)
     if (messageDivUser) messageDivUser.parentNode.remove();
     if (messageDivGpt) messageDivGpt.parentNode.remove();
     const conversation = JSON.parse(localStorage.getItem(`conversation:${window.conversation_id}`));
-    console.log(conversation)
+    // console.log(conversation)
     conversation.items = conversation.items.filter(item => item.token !== token);
-    console.log(conversation)
+    // console.log(conversation)
     localStorage.setItem(`conversation:${window.conversation_id}`, JSON.stringify(conversation));
 
     const messages = document.getElementsByClassName("message");

chatgpt_microservice/deprecated/free_gpt.cpp

@@ -851,73 +851,6 @@ boost::asio::awaitable<void> FreeGpt::chatGptDuo(std::shared_ptr<Channel> ch, nl
     co_return;
 }
 
-boost::asio::awaitable<void> FreeGpt::aivvm(std::shared_ptr<Channel> ch, nlohmann::json json) {
-    boost::system::error_code err{};
-    ScopeExit auto_exit{[&] { ch->close(); }};
-
-    constexpr std::string_view host = "chat.aivvm.com";
-    constexpr std::string_view port = "443";
-
-    constexpr std::string_view user_agent{
-        R"(Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:102.0) Gecko/20100101 Firefox/102.0)"};
-
-    boost::asio::ssl::context ctx(boost::asio::ssl::context::tls);
-    ctx.set_verify_mode(boost::asio::ssl::verify_none);
-
-    auto client = co_await createHttpClient(ctx, host, port);
-    if (!client.has_value()) {
-        SPDLOG_ERROR("createHttpClient: {}", client.error());
-        co_await ch->async_send(err, client.error(), use_nothrow_awaitable);
-        co_return;
-    }
-    auto& stream_ = client.value();
-
-    boost::beast::http::request<boost::beast::http::string_body> req{boost::beast::http::verb::post, "/api/chat", 11};
-    req.set(boost::beast::http::field::host, host);
-    req.set(boost::beast::http::field::user_agent, user_agent);
-    req.set("Accept", "*/*");
-    req.set("accept-language", "zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2");
-    req.set("origin", "https://chat.aivvm.com");
-    req.set("referer", "https://chat.aivvm.com/zh");
-    req.set(boost::beast::http::field::content_type, "application/json");
-    req.set("sec-fetch-dest", "empty");
-    req.set("sec-fetch-mode", "cors");
-    req.set("sec-fetch-site", "same-origin");
-    req.set("DNT", "1");
-
-    constexpr std::string_view json_str = R"({
-        "model":{
-            "id":"gpt-3.5-turbo",
-            "name":"GPT-3.5",
-            "maxLength":12000,
-            "tokenLimit":4096
-        },
-        "messages":[
-            {
-                "role":"user",
-                "content":"hello"
-            }
-        ],
-        "key":"",
-        "prompt":"You are ChatGPT, a large language model trained by OpenAI. Follow the user's instructions carefully. Respond using markdown.",
-        "temperature":0.7
-    })";
-    nlohmann::json request = nlohmann::json::parse(json_str, nullptr, false);
-
-    request["messages"] = getConversationJson(json);
-    SPDLOG_INFO("{}", request.dump(2));
-
-    req.body() = request.dump();
-    req.prepare_payload();
-
-    auto result = co_await sendRequestRecvChunk(ch, stream_, req, 200, [&ch](std::string str) {
-        boost::system::error_code err{};
-        if (!str.empty())
-            ch->try_send(err, str);
-    });
-    co_return;
-}
-
 std::string generateHexStr(int length) {
     std::random_device rd;
     std::mt19937 gen(rd());
@@ -1362,3 +1295,106 @@ create_client:
     co_await ch->async_send(err, rsp.value("data", rsp.dump()), use_nothrow_awaitable);
     co_return;
 }
+
+boost::asio::awaitable<void> FreeGpt::aibn(std::shared_ptr<Channel> ch, nlohmann::json json) {
+    co_await boost::asio::post(boost::asio::bind_executor(*m_thread_pool_ptr, boost::asio::use_awaitable));
+
+    boost::system::error_code err{};
+    ScopeExit _exit{[=] { boost::asio::post(ch->get_executor(), [=] { ch->close(); }); }};
+    auto prompt = json.at("meta").at("content").at("parts").at(0).at("content").get<std::string>();
+
+    CURLcode res;
+    CURL* curl = curl_easy_init();
+    if (!curl) {
+        auto error_info = std::format("curl_easy_init() failed:{}", curl_easy_strerror(res));
+        co_await boost::asio::post(boost::asio::bind_executor(ch->get_executor(), boost::asio::use_awaitable));
+        ch->try_send(err, error_info);
+        co_return;
+    }
+    curl_easy_setopt(curl, CURLOPT_URL, "https://aibn.cc/api/generate");
+    if (!m_cfg.http_proxy.empty())
+        curl_easy_setopt(curl, CURLOPT_PROXY, m_cfg.http_proxy.c_str());
+
+    struct Input {
+        std::shared_ptr<Channel> ch;
+        std::string recv;
+    };
+    Input input{ch};
+    auto action_cb = [](void* contents, size_t size, size_t nmemb, void* userp) -> size_t {
+        boost::system::error_code err{};
+        auto input_ptr = static_cast<Input*>(userp);
+        std::string data{(char*)contents, size * nmemb};
+        auto& [ch, recv] = *input_ptr;
+        boost::asio::post(ch->get_executor(), [=] { ch->try_send(err, data); });
+        return size * nmemb;
+    };
+    size_t (*action_fn)(void* contents, size_t size, size_t nmemb, void* userp) = action_cb;
+    curlEasySetopt(curl);
+    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, action_fn);
+    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &input);
+
+    auto generate_signature = [](int timestamp, const std::string& message, const std::string& secret = "undefined") {
+        std::stringstream ss;
+        ss << timestamp << ":" << message << ":" << secret;
+        std::string data = ss.str();
+
+        unsigned char digest[SHA256_DIGEST_LENGTH];
+        SHA256(reinterpret_cast<const unsigned char*>(data.c_str()), data.length(), digest);
+
+        std::stringstream sha_stream;
+        for (int i = 0; i < SHA256_DIGEST_LENGTH; i++) {
+            sha_stream << std::setfill('0') << std::setw(2) << std::hex << static_cast<int>(digest[i]);
+        }
+        return sha_stream.str();
+    };
+    uint64_t timestamp = getTimestamp<std::chrono::seconds>();
+    std::string signature = generate_signature(timestamp, prompt);
+
+    constexpr std::string_view request_str{R"({
+        "messages":[
+            {
+                "role":"user",
+                "content":"hello"
+            }
+        ],
+        "pass":null,
+        "sign":"7c2700b5813053ff8000cb9fb1ebdadbfcf62882829da59e4474bee466de7c89",
+        "time":1695716667
+    })"};
+    nlohmann::json request = nlohmann::json::parse(request_str, nullptr, false);
+
+    request["sign"] = signature;
+    request["time"] = timestamp;
+    request["messages"] = getConversationJson(json);
+
+    auto str = request.dump();
+    SPDLOG_INFO("request : [{}]", str);
+
+    curl_easy_setopt(curl, CURLOPT_POSTFIELDS, str.c_str());
+
+    struct curl_slist* headers = nullptr;
+    headers = curl_slist_append(headers, "Content-Type: application/json");
+    curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
+
+    ScopeExit auto_exit{[=] {
+        curl_slist_free_all(headers);
+        curl_easy_cleanup(curl);
+    }};
+
+    res = curl_easy_perform(curl);
+
+    if (res != CURLE_OK) {
+        co_await boost::asio::post(boost::asio::bind_executor(ch->get_executor(), boost::asio::use_awaitable));
+        auto error_info = std::format("curl_easy_perform() failed:{}", curl_easy_strerror(res));
+        ch->try_send(err, error_info);
+        co_return;
+    }
+    int32_t response_code;
+    curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &response_code);
+    if (response_code != 200) {
+        co_await boost::asio::post(boost::asio::bind_executor(ch->get_executor(), boost::asio::use_awaitable));
+        ch->try_send(err, std::format("you http code:{}", response_code));
+        co_return;
+    }
+    co_return;
+}

chatgpt_microservice/include/cfg.h

@@ -15,6 +15,7 @@ struct Config {
     std::string api_key;
     std::vector<std::string> ip_white_list;
     std::string zeus{"http://127.0.0.1:8860"};
+    std::string flaresolverr{"http://127.0.0.1:8191/v1"};
 };
 YCS_ADD_STRUCT(Config, client_root_path, interval, work_thread_num, host, port, chat_path, providers, enable_proxy,
-               http_proxy, api_key, ip_white_list, zeus)
+               http_proxy, api_key, ip_white_list, zeus, flaresolverr)

chatgpt_microservice/include/free_gpt.h

@@ -26,7 +26,6 @@ public:
     boost::asio::awaitable<void> binjie(std::shared_ptr<Channel>, nlohmann::json);
     boost::asio::awaitable<void> chatBase(std::shared_ptr<Channel>, nlohmann::json);
     boost::asio::awaitable<void> gptGo(std::shared_ptr<Channel>, nlohmann::json);
-    boost::asio::awaitable<void> aibn(std::shared_ptr<Channel>, nlohmann::json);
     boost::asio::awaitable<void> chatForAi(std::shared_ptr<Channel>, nlohmann::json);
     boost::asio::awaitable<void> freeGpt(std::shared_ptr<Channel>, nlohmann::json);
     boost::asio::awaitable<void> chatGpt4Online(std::shared_ptr<Channel>, nlohmann::json);
@@ -39,6 +38,7 @@ public:
     boost::asio::awaitable<void> chatGptAi(std::shared_ptr<Channel>, nlohmann::json);
     boost::asio::awaitable<void> fakeGpt(std::shared_ptr<Channel>, nlohmann::json);
     boost::asio::awaitable<void> vercel(std::shared_ptr<Channel>, nlohmann::json);
+    boost::asio::awaitable<void> aivvm(std::shared_ptr<Channel>, nlohmann::json);
 
 private:
     boost::asio::awaitable<std::expected<boost::beast::ssl_stream<boost::beast::tcp_stream>, std::string>>

chatgpt_microservice/src/free_gpt.cpp

@@ -1235,7 +1235,8 @@ boost::asio::awaitable<void> FreeGpt::chatBase(std::shared_ptr<Channel> ch, nloh
 
     static std::string chat_id{"z2c2HSfKnCTh5J4650V0I"};
     Curl curl;
-    auto ret = curl.setUrl("https://www.chatbase.co/api/fe/chat")
+    auto ret =
+        curl.setUrl("https://www.chatbase.co/api/fe/chat")
             .setProxy(m_cfg.http_proxy)
             .setRecvBodyCallback([&](std::string str) mutable {
                 boost::asio::post(ch->get_executor(), [=, str = std::move(str)] { ch->try_send(err, str); });
@@ -1265,7 +1266,9 @@ boost::asio::awaitable<void> FreeGpt::chatBase(std::shared_ptr<Channel> ch, nloh
                 nlohmann::json request = nlohmann::json::parse(request_str, nullptr, false);
                 request["chatId"] = chat_id;
                 request["conversationId"] = std::format("kcXpqEnqUie3dnJlsRi_O-{}", chat_id);
-                       request["messages"][1]["content"] = std::format(R"("answer straightforward as a GPT-3.5 Open-Al helpful AI assistant, without introducing yourself except if it is explicitely asked.\n\nUser:\n{}\nGPT-3.5:\n")", prompt);
+                request["messages"][1]["content"] = std::format(
+                    R"("answer straightforward as a GPT-3.5 Open-Al helpful AI assistant, without introducing yourself except if it is explicitely asked.\n\nUser:\n{}\nGPT-3.5:\n")",
+                    prompt);
 
                 auto str = request.dump();
                 SPDLOG_INFO("request : [{}]", str);
@@ -1307,7 +1310,6 @@ boost::asio::awaitable<void> FreeGpt::gptGo(std::shared_ptr<Channel> ch, nlohman
     if (!m_cfg.http_proxy.empty())
         curl_easy_setopt(curl, CURLOPT_PROXY, m_cfg.http_proxy.c_str());
     auto cb = [](void* contents, size_t size, size_t nmemb, void* userp) -> size_t {
-        boost::system::error_code err{};
         auto recv_ptr = static_cast<std::string*>(userp);
         std::string data{(char*)contents, size * nmemb};
         recv_ptr->append(data);
@@ -1415,109 +1417,6 @@ boost::asio::awaitable<void> FreeGpt::gptGo(std::shared_ptr<Channel> ch, nlohman
     co_return;
 }
 
-boost::asio::awaitable<void> FreeGpt::aibn(std::shared_ptr<Channel> ch, nlohmann::json json) {
-    co_await boost::asio::post(boost::asio::bind_executor(*m_thread_pool_ptr, boost::asio::use_awaitable));
-
-    boost::system::error_code err{};
-    ScopeExit _exit{[=] { boost::asio::post(ch->get_executor(), [=] { ch->close(); }); }};
-    auto prompt = json.at("meta").at("content").at("parts").at(0).at("content").get<std::string>();
-
-    CURLcode res;
-    CURL* curl = curl_easy_init();
-    if (!curl) {
-        auto error_info = std::format("curl_easy_init() failed:{}", curl_easy_strerror(res));
-        co_await boost::asio::post(boost::asio::bind_executor(ch->get_executor(), boost::asio::use_awaitable));
-        ch->try_send(err, error_info);
-        co_return;
-    }
-    curl_easy_setopt(curl, CURLOPT_URL, "https://aibn.cc/api/generate");
-    if (!m_cfg.http_proxy.empty())
-        curl_easy_setopt(curl, CURLOPT_PROXY, m_cfg.http_proxy.c_str());
-
-    struct Input {
-        std::shared_ptr<Channel> ch;
-        std::string recv;
-    };
-    Input input{ch};
-    auto action_cb = [](void* contents, size_t size, size_t nmemb, void* userp) -> size_t {
-        boost::system::error_code err{};
-        auto input_ptr = static_cast<Input*>(userp);
-        std::string data{(char*)contents, size * nmemb};
-        auto& [ch, recv] = *input_ptr;
-        boost::asio::post(ch->get_executor(), [=] { ch->try_send(err, data); });
-        return size * nmemb;
-    };
-    size_t (*action_fn)(void* contents, size_t size, size_t nmemb, void* userp) = action_cb;
-    curlEasySetopt(curl);
-    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, action_fn);
-    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &input);
-
-    auto generate_signature = [](int timestamp, const std::string& message, const std::string& secret = "undefined") {
-        std::stringstream ss;
-        ss << timestamp << ":" << message << ":" << secret;
-        std::string data = ss.str();
-
-        unsigned char digest[SHA256_DIGEST_LENGTH];
-        SHA256(reinterpret_cast<const unsigned char*>(data.c_str()), data.length(), digest);
-
-        std::stringstream sha_stream;
-        for (int i = 0; i < SHA256_DIGEST_LENGTH; i++) {
-            sha_stream << std::setfill('0') << std::setw(2) << std::hex << static_cast<int>(digest[i]);
-        }
-        return sha_stream.str();
-    };
-    uint64_t timestamp = getTimestamp<std::chrono::seconds>();
-    std::string signature = generate_signature(timestamp, prompt);
-
-    constexpr std::string_view request_str{R"({
-        "messages":[
-            {
-                "role":"user",
-                "content":"hello"
-            }
-        ],
-        "pass":null,
-        "sign":"7c2700b5813053ff8000cb9fb1ebdadbfcf62882829da59e4474bee466de7c89",
-        "time":1695716667
-    })"};
-    nlohmann::json request = nlohmann::json::parse(request_str, nullptr, false);
-
-    request["sign"] = signature;
-    request["time"] = timestamp;
-    request["messages"] = getConversationJson(json);
-
-    auto str = request.dump();
-    SPDLOG_INFO("request : [{}]", str);
-
-    curl_easy_setopt(curl, CURLOPT_POSTFIELDS, str.c_str());
-
-    struct curl_slist* headers = nullptr;
-    headers = curl_slist_append(headers, "Content-Type: application/json");
-    curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
-
-    ScopeExit auto_exit{[=] {
-        curl_slist_free_all(headers);
-        curl_easy_cleanup(curl);
-    }};
-
-    res = curl_easy_perform(curl);
-
-    if (res != CURLE_OK) {
-        co_await boost::asio::post(boost::asio::bind_executor(ch->get_executor(), boost::asio::use_awaitable));
-        auto error_info = std::format("curl_easy_perform() failed:{}", curl_easy_strerror(res));
-        ch->try_send(err, error_info);
-        co_return;
-    }
-    int32_t response_code;
-    curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &response_code);
-    if (response_code != 200) {
-        co_await boost::asio::post(boost::asio::bind_executor(ch->get_executor(), boost::asio::use_awaitable));
-        ch->try_send(err, std::format("you http code:{}", response_code));
-        co_return;
-    }
-    co_return;
-}
-
 boost::asio::awaitable<void> FreeGpt::chatForAi(std::shared_ptr<Channel> ch, nlohmann::json json) {
     co_await boost::asio::post(boost::asio::bind_executor(*m_thread_pool_ptr, boost::asio::use_awaitable));
 
@@ -3161,3 +3060,152 @@ boost::asio::awaitable<void> FreeGpt::vercel(std::shared_ptr<Channel> ch, nlohma
     ch->try_send(err, "call sdk.vercel.ai error");
     co_return;
 }
+
+boost::asio::awaitable<void> FreeGpt::aivvm(std::shared_ptr<Channel> ch, nlohmann::json json) {
+    boost::system::error_code err{};
+    ScopeExit auto_exit{[&] { ch->close(); }};
+
+    static std::mutex mtx;
+    static std::queue<std::tuple<std::chrono::time_point<std::chrono::system_clock>, std::string>> cookie_queue;
+    std::tuple<std::chrono::time_point<std::chrono::system_clock>, std::string> cookie_cache;
+    std::queue<std::tuple<std::chrono::time_point<std::chrono::system_clock>, std::string>> tmp_queue;
+    std::unique_lock lk(mtx);
+    while (!cookie_queue.empty()) {
+        auto& [time_point, code] = cookie_queue.front();
+        if (std::chrono::system_clock::now() - time_point < std::chrono::minutes(120))
+            tmp_queue.push(std::move(cookie_queue.front()));
+        cookie_queue.pop();
+    }
+    cookie_queue = std::move(tmp_queue);
+    SPDLOG_INFO("cookie_queue size: {}", cookie_queue.size());
+    if (cookie_queue.empty()) {
+        lk.unlock();
+        std::string recv;
+        auto get_cookiet_ret = Curl()
+                                   .setUrl(m_cfg.flaresolverr)
+                                   .setRecvHeadersCallback([](std::string) { return; })
+                                   .setRecvBodyCallback([&](std::string str) mutable {
+                                       recv.append(str);
+                                       return;
+                                   })
+                                   .setBody([] {
+                                       nlohmann::json data{
+                                           {"cmd", "request.get"},
+                                           {"url", "https://chat.aivvm.com/zh"},
+                                           {"maxTimeout", 60000},
+                                       };
+                                       return data.dump();
+                                   }())
+                                   .setHttpHeaders([&] -> auto& {
+                                       static std::unordered_multimap<std::string, std::string> headers{
+                                           {"Accept", "*/*"},
+                                           {"Content-Type", "application/json"},
+                                       };
+                                       return headers;
+                                   }())
+                                   .perform();
+        if (get_cookiet_ret.has_value()) {
+            SPDLOG_ERROR("http://127.0.0.1:8191/v1: [{}]", get_cookiet_ret.value());
+            co_await boost::asio::post(boost::asio::bind_executor(ch->get_executor(), boost::asio::use_awaitable));
+            ch->try_send(err, get_cookiet_ret.value());
+            co_return;
+        }
+
+        nlohmann::json rsp = nlohmann::json::parse(recv, nullptr, false);
+        if (rsp.is_discarded()) {
+            SPDLOG_ERROR("json parse error");
+            co_await ch->async_send(err, "json parse error", use_nothrow_awaitable);
+            co_return;
+        }
+        SPDLOG_INFO("rsp: {}", rsp.dump());
+        auto status = rsp.at("status").get<std::string>();
+        if (status != "ok") {
+            SPDLOG_ERROR("get cookie error");
+            co_await ch->async_send(err, "get cookie error", use_nothrow_awaitable);
+            co_return;
+        }
+        auto it =
+            std::ranges::find_if(rsp["solution"]["cookies"], [](auto& p) { return p["name"] == "cf_clearance"; });
+        if (it == rsp["solution"]["cookies"].end()) {
+            SPDLOG_ERROR("not found cookie");
+            co_await ch->async_send(err, "not found cookie", use_nothrow_awaitable);
+            co_return;
+        }
+        auto cookie_str = std::format("cf_clearance={}", (*it)["value"].get<std::string>());
+        // std::cout << rsp["solution"]["userAgent"].get<std::string>() << std::endl;
+        cookie_cache = std::make_tuple(std::chrono::system_clock::now(), std::move(cookie_str));
+    } else {
+        cookie_cache = std::move(cookie_queue.front());
+        cookie_queue.pop();
+        lk.unlock();
+    }
+    SPDLOG_INFO("cookie: {}", std::get<1>(cookie_cache));
+
+    ScopeExit auto_free([&] {
+        std::lock_guard lk(mtx);
+        cookie_queue.push(std::move(cookie_cache));
+    });
+
+    constexpr std::string_view host = "chat.aivvm.com";
+    constexpr std::string_view port = "443";
+
+    constexpr std::string_view user_agent{
+        R"(Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36)"};
+
+    boost::asio::ssl::context ctx1(boost::asio::ssl::context::tls);
+    ctx1.set_verify_mode(boost::asio::ssl::verify_none);
+
+    auto client = co_await createHttpClient(ctx1, host, port);
+    if (!client.has_value()) {
+        SPDLOG_ERROR("createHttpClient: {}", client.error());
+        co_await ch->async_send(err, client.error(), use_nothrow_awaitable);
+        co_return;
+    }
+    auto& stream_ = client.value();
+
+    boost::beast::http::request<boost::beast::http::string_body> req{boost::beast::http::verb::post, "/api/chat", 11};
+    req.set(boost::beast::http::field::host, host);
+    req.set(boost::beast::http::field::user_agent, user_agent);
+    req.set("Accept", "*/*");
+    req.set("accept-language", "zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2");
+    req.set("origin", "https://chat.aivvm.com");
+    req.set("referer", "https://chat.aivvm.com/zh");
+    req.set(boost::beast::http::field::content_type, "application/json");
+    req.set("sec-fetch-dest", "empty");
+    req.set("sec-fetch-mode", "cors");
+    req.set("sec-fetch-site", "same-origin");
+    req.set("DNT", "1");
+    req.set("Cookie", std::get<1>(cookie_cache));
+
+    constexpr std::string_view json_str = R"({
+        "model":{
+            "id":"gpt-3.5-turbo",
+            "name":"GPT-3.5",
+            "maxLength":12000,
+            "tokenLimit":4096
+        },
+        "messages":[
+            {
+                "role":"user",
+                "content":"hello"
+            }
+        ],
+        "key":"",
+        "prompt":"You are ChatGPT, a large language model trained by OpenAI. Follow the user's instructions carefully. Respond using markdown.",
+        "temperature":0.7
+    })";
+    nlohmann::json request = nlohmann::json::parse(json_str, nullptr, false);
+
+    request["messages"] = getConversationJson(json);
+    SPDLOG_INFO("{}", request.dump(2));
+
+    req.body() = request.dump();
+    req.prepare_payload();
+
+    auto result = co_await sendRequestRecvChunk(ch, stream_, req, 200, [&ch](std::string str) {
+        boost::system::error_code err{};
+        if (!str.empty())
+            ch->try_send(err, str);
+    });
+    co_return;
+}

chatgpt_microservice/src/main.cpp

@@ -67,6 +67,8 @@ void setEnvironment(auto& cfg) {
     }
     if (auto [zeus] = getEnv("ZEUS"); !zeus.empty())
         cfg.zeus = std::move(zeus);
+    if (auto [flaresolverr] = getEnv("FLARESOLVERR"); !flaresolverr.empty())
+        cfg.flaresolverr = std::move(flaresolverr);
 }
 
 std::string createIndexHtml(const std::string& file, const Config& cfg) {
@@ -341,7 +343,6 @@ int main(int argc, char** argv) {
     ADD_METHOD("gpt-3-stream-binjie", FreeGpt::binjie);
     ADD_METHOD("gpt-4-stream-ChatBase", FreeGpt::chatBase);
     ADD_METHOD("gpt-3.5-turbo-stream-GptGo", FreeGpt::gptGo);
-    ADD_METHOD("gpt-3.5-turbo-stream-Aibn", FreeGpt::aibn);
     ADD_METHOD("gpt-3.5-turbo-stream-FreeGpt", FreeGpt::freeGpt);
     ADD_METHOD("gpt-4-stream-Chatgpt4Online", FreeGpt::chatGpt4Online);
     ADD_METHOD("gpt-3.5-turbo-stream-gptalk", FreeGpt::gptalk);
@@ -354,6 +355,7 @@ int main(int argc, char** argv) {
     ADD_METHOD("gpt-3.5-turbo-stream-chatGptAi", FreeGpt::chatGptAi);
     ADD_METHOD("gpt-3.5-turbo-stream-FakeGpt", FreeGpt::fakeGpt);
     ADD_METHOD("gpt-3.5-turbo-stream-Vercel", FreeGpt::vercel);
+    ADD_METHOD("gpt-3.5-turbo-stream-aivvm", FreeGpt::aivvm);
 
     SPDLOG_INFO("active provider:");
     for (auto& [provider, _] : gpt_function)