PersonalPublic/gpt_chat_bot
1
0
Fork 0
mirror of https://github.com/Balshgit/gpt_chat_bot.git synced 2025-09-11 22:30:41 +03:00
Code Issues Packages Projects Releases Wiki Activity

remove provider aibn (#49)

Browse Source 
Remove provider aibn
This commit is contained in:
Dmitry Afanasyev 2023-11-02 00:26:15 +03:00 committed by GitHub
parent e929717b15
commit 2789b33677
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
8 changed files with 308 additions and 210 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
bot_microservice/constants.py
View File

@ -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]:

15
chatgpt_microservice/README.md
View File

@ -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
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.
### Start the Zeus Service [optional]
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

16
chatgpt_microservice/client/js/chat.js
View File

@ -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");

170
chatgpt_microservice/deprecated/free_gpt.cpp
View File

@ -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;
}

3
chatgpt_microservice/include/cfg.h
View File

@ -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)

2
chatgpt_microservice/include/free_gpt.h
View File

@ -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>>

260
chatgpt_microservice/src/free_gpt.cpp
View File

@ -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;
}

4
chatgpt_microservice/src/main.cpp
View File

@ -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)