197 lines
6.4 KiB
C++
197 lines
6.4 KiB
C++
#include "openrouter/chat_model.h"
|
|
|
|
#include "llm/error.h"
|
|
#include "openrouter/server_tools.h"
|
|
#include "security/crypto/Base64.h"
|
|
|
|
namespace molo::openrouter {
|
|
|
|
using clients::body::Json;
|
|
|
|
namespace {
|
|
|
|
[[noreturn]] void bad(const std::string& why) {
|
|
throw llm::ApiError::invalid(kVendor, why);
|
|
}
|
|
|
|
std::string image_url(const llm::ImageData& image) {
|
|
if (!image.url.empty()) return image.url;
|
|
if (image.bytes.empty() || image.mime.empty()) bad("image needs a url or bytes plus mime");
|
|
return "data:" + image.mime + ";base64," + security::crypto::Base64::encode(image.bytes);
|
|
}
|
|
|
|
Json text_part(const std::string& text) {
|
|
Json p = Json::object();
|
|
p.set("type", Json("text"));
|
|
p.set("text", Json(text));
|
|
return p;
|
|
}
|
|
|
|
Json user_content(const llm::Message& m) {
|
|
bool has_image = false;
|
|
for (const llm::ContentPart& p : m.parts)
|
|
if (p.image) has_image = true;
|
|
if (!has_image) return Json(m.text());
|
|
Json arr = Json::array();
|
|
for (const llm::ContentPart& p : m.parts) {
|
|
if (!p.text.empty()) arr.push(text_part(p.text));
|
|
if (p.image) {
|
|
Json img = Json::object();
|
|
img.set("url", Json(image_url(*p.image)));
|
|
Json part = Json::object();
|
|
part.set("type", Json("image_url"));
|
|
part.set("image_url", img);
|
|
arr.push(part);
|
|
}
|
|
}
|
|
return arr;
|
|
}
|
|
|
|
void add_messages(const llm::ChatRequest& req, Json& out) {
|
|
if (!req.system.empty()) {
|
|
Json m = Json::object();
|
|
m.set("role", Json("system"));
|
|
m.set("content", Json(req.system));
|
|
out.push(m);
|
|
}
|
|
for (const llm::Message& msg : req.messages) {
|
|
switch (msg.role) {
|
|
case llm::Role::kSystem: {
|
|
Json m = Json::object();
|
|
m.set("role", Json("system"));
|
|
m.set("content", Json(msg.text()));
|
|
if (!msg.name.empty()) m.set("name", Json(msg.name));
|
|
out.push(m);
|
|
break;
|
|
}
|
|
case llm::Role::kUser: {
|
|
Json m = Json::object();
|
|
m.set("role", Json("user"));
|
|
m.set("content", user_content(msg));
|
|
if (!msg.name.empty()) m.set("name", Json(msg.name));
|
|
out.push(m);
|
|
break;
|
|
}
|
|
case llm::Role::kAssistant: {
|
|
Json m = Json::object();
|
|
m.set("role", Json("assistant"));
|
|
std::string text = msg.text();
|
|
Json calls = Json::array();
|
|
for (const llm::ContentPart& p : msg.parts) {
|
|
if (!p.tool_call) continue;
|
|
Json fn = Json::object();
|
|
fn.set("name", Json(p.tool_call->name));
|
|
fn.set("arguments", Json(p.tool_call->arguments.dump()));
|
|
Json call = Json::object();
|
|
call.set("id", Json(p.tool_call->id));
|
|
call.set("type", Json("function"));
|
|
call.set("function", fn);
|
|
calls.push(call);
|
|
}
|
|
if (!text.empty() || calls.as_array().empty()) m.set("content", Json(text));
|
|
else m.set("content", Json());
|
|
if (!calls.as_array().empty()) m.set("tool_calls", calls);
|
|
if (!msg.name.empty()) m.set("name", Json(msg.name));
|
|
out.push(m);
|
|
break;
|
|
}
|
|
case llm::Role::kTool: {
|
|
for (const llm::ContentPart& p : msg.parts) {
|
|
if (!p.tool_result) continue;
|
|
Json m = Json::object();
|
|
m.set("role", Json("tool"));
|
|
m.set("tool_call_id", Json(p.tool_result->call_id));
|
|
m.set("content", Json(p.tool_result->content));
|
|
out.push(m);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
} // namespace
|
|
|
|
OpenrouterChatModel::OpenrouterChatModel(std::shared_ptr<Gateway> gateway,
|
|
std::string default_model, ChatModelDefaults defaults)
|
|
: service_(std::move(gateway)),
|
|
default_model_(std::move(default_model)),
|
|
defaults_(std::move(defaults)) {}
|
|
|
|
Json OpenrouterChatModel::to_body(const llm::ChatRequest& req) const {
|
|
ChatParams p;
|
|
p.model = req.model.empty() ? default_model_ : req.model;
|
|
p.models = defaults_.fallback_models;
|
|
add_messages(req, p.messages);
|
|
for (const llm::ToolSpec& t : req.tools) p.tools.push(ServerTools::function(t));
|
|
if (!req.tool_choice.empty()) {
|
|
if (req.tool_choice == "auto" || req.tool_choice == "none" || req.tool_choice == "required") {
|
|
p.tool_choice = Json(req.tool_choice);
|
|
} else {
|
|
Json fn = Json::object();
|
|
fn.set("name", Json(req.tool_choice));
|
|
Json tc = Json::object();
|
|
tc.set("type", Json("function"));
|
|
tc.set("function", fn);
|
|
p.tool_choice = tc;
|
|
}
|
|
}
|
|
if (req.max_tokens) p.max_tokens = *req.max_tokens;
|
|
p.temperature = req.temperature;
|
|
p.top_p = req.top_p;
|
|
p.stop = req.stop;
|
|
if (req.response_schema.is_object()) {
|
|
p.response_format = ResponseFormats::json_schema("response", req.response_schema, true);
|
|
} else if (req.json_mode) {
|
|
p.response_format = ResponseFormats::json_object();
|
|
}
|
|
p.provider = defaults_.provider;
|
|
p.plugins = defaults_.plugins;
|
|
p.route = defaults_.route;
|
|
p.reasoning = defaults_.reasoning;
|
|
if (!req.reasoning_effort.empty()) p.reasoning = ReasoningConfig::with_effort(req.reasoning_effort);
|
|
|
|
Json body = p.to_json(false);
|
|
if (!req.extra.is_null()) {
|
|
if (!req.extra.is_object()) bad("ChatRequest::extra must be an object");
|
|
for (const auto& [k, v] : req.extra.as_object()) {
|
|
if (!CallPlanner::accepts_field("sendChatCompletionRequest", k))
|
|
bad("extra field not in the spec: " + k);
|
|
body.set(k, v);
|
|
}
|
|
}
|
|
return body;
|
|
}
|
|
|
|
llm::ChatResponse OpenrouterChatModel::to_response(const ChatResult& r) {
|
|
llm::ChatResponse out;
|
|
out.id = r.id;
|
|
out.model = r.model;
|
|
out.raw = r.raw;
|
|
out.message.role = llm::Role::kAssistant;
|
|
if (!r.choices.empty()) {
|
|
const ChatChoiceResult& c = r.first();
|
|
out.finish_reason = c.finish_reason;
|
|
if (!c.content.empty() || !c.reasoning.empty()) {
|
|
llm::ContentPart part = llm::ContentPart::of_text(c.content);
|
|
part.reasoning = c.reasoning;
|
|
out.message.parts.push_back(std::move(part));
|
|
}
|
|
for (const llm::ToolCall& call : c.tool_calls)
|
|
out.message.parts.push_back(llm::ContentPart::of_call(call));
|
|
}
|
|
if (r.usage) out.usage = *r.usage;
|
|
return out;
|
|
}
|
|
|
|
llm::ChatResponse OpenrouterChatModel::generate(const llm::ChatRequest& request) {
|
|
return to_response(ChatResult::parse(service_.create_raw(to_body(request))));
|
|
}
|
|
|
|
void OpenrouterChatModel::stream(const llm::ChatRequest& request,
|
|
const std::function<bool(const llm::ChatChunk&)>& on_chunk) {
|
|
service_.stream_body(to_body(request), on_chunk);
|
|
}
|
|
|
|
} // namespace molo::openrouter
|