Files
moloapp/src/openrouter/chat_model.cpp
T

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