Files
moloapp/src/vendors/retrieval/brave/brave.cpp
T

173 lines
5.7 KiB
C++
Raw Normal View History

#include "vendors/retrieval/brave/brave.h"
#include "vendors/retrieval/caps.h"
namespace molo::retrieval {
llm::ApiClientConfig Brave::config() {
llm::ApiClientConfig c;
c.vendor = "brave";
c.base_url = kBaseUrl;
c.key_env = kKeyEnv;
c.auth = llm::AuthStyle::kHeader;
c.auth_header = "X-Subscription-Token";
c.default_headers["Accept"] = "application/json";
return c;
}
namespace {
[[noreturn]] void bad(const std::string& why) { throw llm::ApiError::invalid("brave", why); }
void check_query(const std::string& q, std::size_t max_chars) {
if (q.find_first_not_of(" \t\r\n") == std::string::npos) bad("query is blank");
if (q.size() > max_chars) bad("query is over the documented length");
}
void check_count(int count, int max) {
if (count < 1 || count > max) bad("count must be 1.." + std::to_string(max));
}
CallArgs query_args(const std::string& q, int count, const std::string& freshness) {
CallArgs a;
a.query["q"] = q;
a.query["count"] = Query::number(count);
if (!freshness.empty()) a.query["freshness"] = freshness;
return a;
}
} // namespace
Brave Brave::from_env() { return Brave(make_gateway(brave_calls(), config(), {{"main", kBaseUrl}}, "", nullptr)); }
Brave Brave::with(const TransportFactory& factory, std::string key) {
return Brave(make_gateway(brave_calls(), config(), {{"main", kBaseUrl}}, std::move(key), factory));
}
std::string Brave::freshness_of(const std::string& r) {
if (r == "day") return "pd";
if (r == "week") return "pw";
if (r == "month") return "pm";
if (r == "year") return "py";
return "";
}
SearchResult Brave::parse_web(const Json& doc) {
SearchResult out;
const Json* web = J::at(doc, "web");
if (!web) return out;
for (const Json& r : J::array(*web, "results")) {
SearchHit h;
h.title = J::str(r, "title");
h.url = J::str(r, "url");
h.snippet = J::str(r, "description");
h.published = J::str(r, "page_age");
out.hits.push_back(std::move(h));
}
return out;
}
SearchResult Brave::parse_results(const Json& doc) {
SearchResult out;
for (const Json& r : J::array(doc, "results")) {
SearchHit h;
h.title = J::str(r, "title");
h.url = J::str(r, "url");
h.snippet = J::str(r, "description");
h.published = J::str(r, "page_age");
if (h.published.empty()) h.published = J::str(r, "age");
out.hits.push_back(std::move(h));
}
return out;
}
std::vector<BraveImage> Brave::parse_images(const Json& doc) {
std::vector<BraveImage> out;
for (const Json& r : J::array(doc, "results")) {
BraveImage i;
i.title = J::str(r, "title");
i.page_url = J::str(r, "url");
i.source = J::str(r, "source");
if (const Json* p = J::at(r, "properties")) i.image_url = J::str(*p, "url");
out.push_back(std::move(i));
}
return out;
}
std::vector<std::string> Brave::parse_suggest(const Json& doc) {
std::vector<std::string> out;
for (const Json& r : J::array(doc, "results")) out.push_back(J::str(r, "query"));
return out;
}
std::string Brave::parse_answer(const Json& doc) {
const Json::Array& choices = J::array(doc, "choices");
if (choices.empty()) return "";
if (const Json* m = J::at(choices.front(), "message")) return J::str(*m, "content");
if (const Json* d = J::at(choices.front(), "delta")) return J::str(*d, "content");
return "";
}
SearchResult Brave::search(const SearchRequest& request) {
WebSearch::validate("brave", request);
check_query(request.query, 600);
check_count(request.max_results, 20);
return parse_web(gw_->call("web_search", query_args(request.query, request.max_results, freshness_of(request.recency))));
}
SearchResult Brave::news(const SearchRequest& request) {
WebSearch::validate("brave", request);
check_query(request.query, RetrievalCaps::kBraveQueryChars);
check_count(request.max_results, RetrievalCaps::kBraveMaxCount);
return parse_results(gw_->call("news_search", query_args(request.query, request.max_results, freshness_of(request.recency))));
}
SearchResult Brave::videos(const SearchRequest& request) {
WebSearch::validate("brave", request);
check_query(request.query, RetrievalCaps::kBraveQueryChars);
check_count(request.max_results, RetrievalCaps::kBraveMaxCount);
return parse_results(gw_->call("video_search", query_args(request.query, request.max_results, freshness_of(request.recency))));
}
std::vector<BraveImage> Brave::images(const std::string& query, int count) {
check_query(query, RetrievalCaps::kBraveQueryChars);
check_count(count, 200);
return parse_images(gw_->call("image_search", query_args(query, count, "")));
}
std::vector<std::string> Brave::suggest(const std::string& query, int count) {
check_query(query, RetrievalCaps::kBraveQueryChars);
check_count(count, 20);
CallArgs a;
a.query["q"] = query;
a.query["count"] = Query::number(count);
return parse_suggest(gw_->call("suggest", a));
}
Json Brave::spellcheck(const std::string& query) {
check_query(query, RetrievalCaps::kBraveQueryChars);
CallArgs a;
a.query["q"] = query;
return gw_->call("spellcheck", a);
}
Json Brave::llm_context(const std::string& query) {
check_query(query, RetrievalCaps::kBraveQueryChars);
CallArgs a;
a.query["q"] = query;
return gw_->call("llm_context", a);
}
std::string Brave::answer(const std::string& prompt) {
if (prompt.find_first_not_of(" \t\r\n") == std::string::npos || prompt.size() > RetrievalCaps::kMaxQueryChars)
bad("prompt must be 1..8192 chars");
Json msg = Json::object();
msg.set("role", Json("user"));
msg.set("content", Json(prompt));
Json msgs = Json::array();
msgs.push(msg);
Json body = Json::object();
body.set("messages", msgs);
body.set("stream", Json(false));
CallArgs a;
a.body = body;
return parse_answer(gw_->call("answers", a));
}
} // namespace molo::retrieval