Merge openrouter package

This commit is contained in:
2026-10-24 07:46:58 +02:00
54 changed files with 7109 additions and 3 deletions
+74
View File
@@ -0,0 +1,74 @@
// Opt-in live checks against OpenRouter (MOLO_LIVE_NET=1). The public
// listing routes need no key. Everything else needs OPENROUTER_API_KEY (or
// OPENROUTER_MANAGEMENT_KEY for credits) and is read-only; the single smallest
// completion additionally needs MOLO_LIVE_PAID=1. Nothing is created, changed
// or deleted. Without the opt-in a loud SKIP is printed.
#include <cstdlib>
#include <iostream>
#include "framework.h"
#include "llm/config.h"
#include "openrouter/account.h"
#include "openrouter/chat_model.h"
#include "openrouter/gateway.h"
#include "openrouter/model_ref.h"
#include "openrouter/models.h"
using namespace molo::openrouter;
namespace {
// Read at static init: llm.config_lookup_order_and_off_switch (same binary)
// unsets MOLO_LIVE_NET before these tests run.
const bool kLive = std::getenv("MOLO_LIVE_NET") != nullptr;
const bool kPaid = kLive && std::getenv("MOLO_LIVE_PAID") != nullptr;
bool live() { return kLive; }
bool paid() { return kPaid; }
} // namespace
TEST(openrouter_live, public_catalog_without_a_key) {
if (!live()) {
std::cout << "SKIP openrouter_live.public_catalog_without_a_key (set MOLO_LIVE_NET=1)\n";
return;
}
auto gw = Gateway::from_env();
ModelsService models(gw);
ASSERT_TRUE(models.count() > 0);
ModelList all = models.list_all();
ASSERT_TRUE(!all.models.empty());
ASSERT_TRUE(all.truncated || static_cast<long>(all.models.size()) == all.total_count);
// Every live model id must be a well-formed ModelRef (variants included).
for (const ModelInfo& m : all.models) ModelRef::parse(m.id);
ModelEndpoints ep = models.endpoints("openai/gpt-4o");
ASSERT_TRUE(!ep.endpoints.empty());
ASSERT_TRUE(!ProvidersService(gw).list().empty());
ModelFilter f;
f.limit = 3;
f.sort = "newest";
ASSERT_EQ(models.page(f).models.size(), 3u);
}
TEST(openrouter_live, key_info_and_one_tiny_completion) {
if (!live() || molo::llm::Config::get(kApiKeyEnv).empty()) {
std::cout << "SKIP openrouter_live.key_info_and_one_tiny_completion (set MOLO_LIVE_NET=1 and OPENROUTER_API_KEY)\n";
return;
}
auto gw = Gateway::from_env();
ASSERT_TRUE(!AccountService(gw).key_info().label.empty());
if (!paid()) {
std::cout << "SKIP completion (set MOLO_LIVE_PAID=1)\n";
return;
}
OpenrouterChatModel model(gw, "openrouter/free");
molo::llm::ChatRequest req;
req.messages.push_back(molo::llm::Message::user("Say hi in two words."));
req.max_tokens = 16;
ASSERT_TRUE(!model.generate(req).text().empty());
}
TEST(openrouter_live, credits_with_the_management_key) {
if (!live() || molo::llm::Config::get(kManagementKeyEnv).empty()) {
std::cout << "SKIP openrouter_live.credits_with_the_management_key (set MOLO_LIVE_NET=1 and OPENROUTER_MANAGEMENT_KEY)\n";
return;
}
ASSERT_TRUE(AccountService(Gateway::from_env()).credits().total_credits >= 0);
}
+268
View File
@@ -0,0 +1,268 @@
// Deterministic local tests for the OpenRouter module: the call table, request
// planning and validation, value classes (model variants, provider
// preferences, reasoning, plugins, server tools), stream parsing with a
// documented transcript, error semantics, key routing, PKCE. No OpenRouter
// reply is scripted anywhere: transports only record the requests they get.
#include <memory>
#include <set>
#include "clients/transports/mock_transport.h"
#include "framework.h"
#include "llm/sse.h"
#include "openrouter/account.h"
#include "openrouter/admin.h"
#include "openrouter/call_plan.h"
#include "openrouter/caps.h"
#include "openrouter/chat_model.h"
#include "openrouter/chat_params.h"
#include "openrouter/chat_service.h"
#include "openrouter/chat_stream.h"
#include "openrouter/errors.h"
#include "openrouter/gateway.h"
#include "openrouter/inference_services.h"
#include "openrouter/model_ref.h"
#include "openrouter/models.h"
#include "openrouter/platform.h"
#include "openrouter/plugins.h"
#include "openrouter/server_tools.h"
using namespace molo::openrouter;
using molo::clients::Method;
using molo::clients::body::Json;
using molo::clients::transports::MockTransport;
using molo::llm::ApiError;
namespace {
PathArgs dummy_args(const CallSpec& s) {
PathArgs a;
for (const std::string& p : CallPlanner::placeholders(s.path)) a[p] = "x1";
return a;
}
} // namespace
TEST(openrouter, table_is_complete_and_plannable) {
ASSERT_EQ(kCallCount, 140u);
std::set<std::string> names;
int mgmt = 0, none = 0, api = 0;
for (const CallSpec& s : kCalls) {
ASSERT_TRUE(names.insert(s.name).second);
PlannedCall p = CallPlanner::plan(s.name, dummy_args(s));
ASSERT_EQ(p.name(), std::string(s.name));
ASSERT_TRUE(p.path.find('{') == std::string::npos);
ASSERT_TRUE(p.path.front() == '/');
if (p.key == KeyKind::kManagement) ++mgmt;
else if (p.key == KeyKind::kNone) ++none;
else ++api;
}
ASSERT_EQ(mgmt + none + api, 140);
ASSERT_TRUE(mgmt > 50 && none >= 10 && api > 40);
ASSERT_TRUE(CallPlanner::spec("getModels").key == std::string("none"));
ASSERT_TRUE(CallPlanner::spec("getCredits").key == std::string("mgmt"));
ASSERT_TRUE(CallPlanner::spec("sendChatCompletionRequest").key == std::string("api"));
}
TEST(openrouter, planner_rejects_what_the_table_does_not_declare) {
Json body = Json::object();
body.set("nonsense", Json(1));
ASSERT_THROW(CallPlanner::plan("noSuchCall"), ApiError);
ASSERT_THROW(CallPlanner::plan("getKey"), ApiError); // missing {hash}
ASSERT_THROW(CallPlanner::plan("getKey", {{"hash", "a/b"}}), ApiError); // bad segment
ASSERT_THROW(CallPlanner::plan("getKey", {{"hash", "x"}, {"extra", "y"}}), ApiError);
ASSERT_THROW(CallPlanner::plan("getModels", {}, Query().add("bogus", "1")), ApiError);
ASSERT_THROW(CallPlanner::plan("sendChatCompletionRequest", {}, {}, &body), ApiError);
ASSERT_THROW(CallPlanner::plan("getCredits", {}, {}, &body), ApiError); // no body allowed
Json ok = Json::object();
ok.set("messages", Json::array());
PlannedCall p = CallPlanner::plan("sendChatCompletionRequest", {}, {}, &ok);
ASSERT_TRUE(p.has_body);
ASSERT_EQ(p.path, "/chat/completions");
PlannedCall q = CallPlanner::plan("getModels", {}, Query().add("q", "a b&c").add("limit", 5));
ASSERT_EQ(q.query, "?q=a%20b%26c&limit=5");
// Partner text is encoded, "." cannot be addressed.
ASSERT_EQ(CallPlanner::plan("getExternalUser", {{"user", "a b/c"}}).path, "/external-users/a%20b%2Fc");
ASSERT_THROW(CallPlanner::plan("getExternalUser", {{"user", ".."}}), ApiError);
// Alias authors keep their marker.
ASSERT_EQ(CallPlanner::plan("getModel", {{"author", "~openai"}, {"slug", "gpt-latest"}}).path,
"/model/~openai/gpt-latest");
auto [a, s] = split_model_id("openai/gpt-4o:free");
ASSERT_EQ(a, "openai");
ASSERT_EQ(s, "gpt-4o:free");
ASSERT_THROW(split_model_id("gpt-4o"), ApiError);
ASSERT_THROW(split_model_id("a/b/c"), ApiError);
}
TEST(openrouter, model_variants) {
ModelRef m = ModelRef::parse("poolside/laguna-s-2.1:free:nitro");
ASSERT_EQ(m.base(), "poolside/laguna-s-2.1");
ASSERT_EQ(m.catalog_variant(), "free");
ASSERT_EQ(m.catalog_id(), "poolside/laguna-s-2.1:free"); // :free is kept, :nitro dropped
ASSERT_EQ(m.str(), "poolside/laguna-s-2.1:free:nitro");
ASSERT_FALSE(m.uses_deprecated_variant());
ASSERT_TRUE(ModelRef::parse("openai/gpt-5.2:online").uses_deprecated_variant());
ASSERT_EQ(ModelRef::parse("openai/gpt-5.2:nitro:exacto").catalog_id(), "openai/gpt-5.2");
ASSERT_EQ(ModelRef::parse("~openai/gpt-latest").author(), "~openai");
ASSERT_THROW(ModelRef::parse("openai/gpt:free:thinking"), ApiError); // two catalog variants
ASSERT_THROW(ModelRef::parse("openai/gpt:bogus"), ApiError);
ASSERT_THROW(ModelRef::parse("gpt"), ApiError);
ASSERT_EQ(ModelRef::parse("a/b").with_variant("floor").with_variant("floor").str(), "a/b:floor");
ASSERT_EQ(ModelRef::parse("a/b:free:nitro").without_routing_variants().str(), "a/b:free");
}
TEST(openrouter, provider_preferences) {
ProviderPreferences p;
p.order = {"anthropic", "openai"};
p.allow_fallbacks = false;
p.require_parameters = true;
p.data_collection = "deny";
p.zdr = true;
p.quantizations = {"fp8", "bf16"};
p.sort = "throughput";
p.sort_partition = "none";
p.max_price = {{"prompt", "1"}, {"completion", "2.5"}};
p.preferred_max_latency_percentiles = {{"p90", 3.0}};
p.preferred_min_throughput = 50;
Json j = p.to_json();
ASSERT_EQ(j.find("order")->as_array().size(), 2u);
ASSERT_FALSE(j.find("allow_fallbacks")->as_bool());
ASSERT_EQ(j.find("sort")->find("by")->as_string(), "throughput");
ASSERT_EQ(j.find("max_price")->find("completion")->as_string(), "2.5");
ASSERT_EQ(j.find("preferred_max_latency")->find("p90")->as_number(), 3.0);
ASSERT_EQ(j.find("preferred_min_throughput")->as_number(), 50.0);
ProviderPreferences back = ProviderPreferences::from_json(j);
ASSERT_TRUE(back.to_json().equals(j));
ASSERT_TRUE(ProviderPreferences().empty());
ASSERT_EQ(ProviderPreferences::cheapest().to_json().find("sort")->as_string(), "price");
ProviderPreferences bad = p;
bad.quantizations = {"fp99"};
ASSERT_THROW(bad.validate(), ApiError);
bad = p;
bad.data_collection = "maybe";
ASSERT_THROW(bad.validate(), ApiError);
bad = p;
bad.sort = "cheap";
ASSERT_THROW(bad.validate(), ApiError);
bad = p;
bad.max_price["prompt"] = "-1";
ASSERT_THROW(bad.validate(), ApiError);
bad = p;
bad.max_price["tokens"] = "1";
ASSERT_THROW(bad.validate(), ApiError);
bad = p;
bad.preferred_min_throughput_percentiles = {{"p50", 1}};
ASSERT_THROW(bad.validate(), ApiError); // number and percentiles together
bad = ProviderPreferences();
bad.only.assign(Caps::kMaxProviderList + 1, "x");
ASSERT_THROW(bad.validate(), ApiError);
bad = ProviderPreferences();
bad.order = {"bad slug!"};
ASSERT_THROW(bad.validate(), ApiError);
}
TEST(openrouter, reasoning_plugins_server_tools) {
ASSERT_EQ(ReasoningConfig::with_effort("high").to_json().find("effort")->as_string(), "high");
ASSERT_TRUE(ReasoningConfig::hidden("low").to_json().find("exclude")->as_bool());
ASSERT_EQ(ReasoningConfig::with_budget(2000).to_json().find("max_tokens")->as_int(), 2000);
ASSERT_THROW(ReasoningConfig::with_effort("extreme"), ApiError);
ReasoningConfig both;
both.effort = "low";
both.max_tokens = 10;
ASSERT_THROW(both.validate(), ApiError);
WebSearchPlugin web;
web.engine = "exa";
web.max_results = 3;
web.include_domains = {"*.example.com"};
Json w = web.to_json();
ASSERT_EQ(w.find("id")->as_string(), "web");
ASSERT_EQ(w.find("engine")->as_string(), "exa");
web.engine = "bing";
ASSERT_THROW(web.to_json(), ApiError);
FileParserPlugin fp;
fp.pdf_engine = "mistral-ocr";
ASSERT_EQ(fp.to_json().find("pdf")->find("engine")->as_string(), "mistral-ocr");
ResponseHealingPlugin heal;
heal.enabled = false;
ASSERT_FALSE(heal.to_json().find("enabled")->as_bool());
ASSERT_EQ(ContextCompressionPlugin().to_json().find("engine")->as_string(), "middle-out");
AutoRouterPlugin ar;
ar.allowed_models = {"anthropic/*"};
ar.cost_tier = "low";
ASSERT_EQ(ar.to_json().find("cost_tier")->as_string(), "low");
ASSERT_TRUE(Plugin::is_known("pareto-router"));
ASSERT_FALSE(Plugin::is_known("nope"));
ASSERT_THROW(RawPlugin("nope", Json::object()).to_json(), ApiError);
ASSERT_EQ(RawPlugin("pareto-router", Json::object()).to_json().find("id")->as_string(), "pareto-router");
std::vector<PluginPtr> twice = {std::make_shared<ResponseHealingPlugin>(), std::make_shared<ResponseHealingPlugin>()};
ASSERT_THROW(plugins_to_json(twice), ApiError);
std::vector<PluginPtr> many(Caps::kMaxPlugins + 1, std::make_shared<ModerationPlugin>());
ASSERT_THROW(plugins_to_json(many), ApiError);
ASSERT_EQ(ServerTools::web_search().find("type")->as_string(), "openrouter:web_search");
ASSERT_THROW(ServerTools::server("web_search"), ApiError);
ASSERT_THROW(ServerTools::server("openrouter:Bad Name"), ApiError);
Json fn = ServerTools::function("get_weather", "weather", Json::object(), true);
ASSERT_TRUE(fn.find("function")->find("strict")->as_bool());
ASSERT_THROW(ServerTools::function("bad name", "", Json::object()), ApiError);
}
TEST(openrouter, chat_params_emit_only_declared_fields) {
ChatParams p = ChatParams::simple("openai/gpt-4o:nitro", "hi");
p.models = {"anthropic/claude-3.5-sonnet"};
p.temperature = 0.5;
p.top_p = 0.9;
p.top_k = 40;
p.min_p = 0.1;
p.top_a = 0.1;
p.repetition_penalty = 1.1;
p.frequency_penalty = 0.1;
p.presence_penalty = 0.1;
p.max_tokens = 100;
p.max_completion_tokens = 100;
p.seed = 7;
p.logprobs = true;
p.top_logprobs = 5;
p.stop = {"END"};
p.logit_bias = Json::object();
p.response_format = ResponseFormats::json_schema("answer", Json::object());
p.tools.push(ServerTools::web_search());
p.tool_choice = Json("auto");
p.parallel_tool_calls = true;
p.provider = ProviderPreferences::cheapest();
p.reasoning = ReasoningConfig::with_effort("medium");
p.plugins = {std::make_shared<ResponseHealingPlugin>()};
p.route = "fallback";
p.modalities = {"text"};
p.service_tier = "flex";
p.user = "u1";
p.session_id = "s1";
p.prompt_cache_key = "k";
p.metadata = Json::object();
p.metadata.set("a", Json("b"));
p.trace = Json::object();
p.prediction = Json::object();
p.debug = Json::object();
Json body = p.to_json(true);
for (const auto& [k, v] : body.as_object()) {
(void)v;
if (!CallPlanner::accepts_field("sendChatCompletionRequest", k)) FAIL("undeclared key emitted: " + k);
}
ASSERT_TRUE(body.find("stream")->as_bool());
CallPlanner::plan("sendChatCompletionRequest", {}, {}, &body); // does not throw
ChatParams bad = ChatParams::simple("a/b", "x");
bad.temperature = 3;
ASSERT_THROW(bad.validate(), ApiError);
bad = ChatParams::simple("a/b", "x");
bad.reasoning = ReasoningConfig::with_effort("low");
bad.reasoning_effort = "low";
ASSERT_THROW(bad.validate(), ApiError);
bad = ChatParams::simple("a/b", "x");
bad.stop = {"1", "2", "3", "4", "5"};
ASSERT_THROW(bad.validate(), ApiError);
bad = ChatParams::simple("a/b", "x");
bad.extra.set("not_a_field", Json(1));
ASSERT_THROW(bad.to_json(), ApiError); // extra fields must be in the table
}
@@ -0,0 +1,451 @@
// OpenRouter wire-level local tests: SSE stream parsing, error semantics, key
// routing and attribution headers, PKCE, account / model value types, chat
// model mapping. Fixtures marked "docs" are taken verbatim from OpenRouter's
// documentation or the OpenAPI examples; nothing is scripted as a reply.
#include <memory>
#include "clients/transports/mock_transport.h"
#include "framework.h"
#include "llm/sse.h"
#include "openrouter/account.h"
#include "openrouter/admin.h"
#include "openrouter/chat_model.h"
#include "openrouter/chat_service.h"
#include "openrouter/chat_stream.h"
#include "openrouter/errors.h"
#include "openrouter/gateway.h"
#include "openrouter/inference_services.h"
#include "openrouter/models.h"
#include "openrouter/platform.h"
using namespace molo::openrouter;
using molo::clients::body::Json;
using molo::clients::transports::MockTransport;
using molo::llm::ApiError;
namespace {
struct Rig {
MockTransport* api_t;
MockTransport* mgmt_t;
MockTransport* anon_t;
std::shared_ptr<Gateway> gateway;
explicit Rig(const std::string& api_key = "APIKEY", const std::string& mgmt_key = "MGMTKEY") {
auto a = std::make_unique<MockTransport>();
auto m = std::make_unique<MockTransport>();
auto n = std::make_unique<MockTransport>();
api_t = a.get();
mgmt_t = m.get();
anon_t = n.get();
Attribution attr;
attr.referer = "https://myapp.example";
attr.title = "My App";
attr.categories = "cli-agent,cloud-agent";
attr.router_metadata = true;
auto headers = attr.headers();
molo::llm::ApiClientConfig c;
c.vendor = kVendor;
c.base_url = kDefaultBaseUrl;
c.default_headers = headers;
c.key_env = kApiKeyEnv;
auto api = std::make_shared<molo::llm::ApiClient>(std::move(a), c, api_key);
c.key_env = kManagementKeyEnv;
auto mgmt = std::make_shared<molo::llm::ApiClient>(std::move(m), c, mgmt_key);
auto anon = std::make_shared<AnonymousClient>(std::move(n), kDefaultBaseUrl, headers);
gateway = std::make_shared<Gateway>(api, mgmt, anon);
}
};
template <typename F>
void swallow(F&& f) {
try {
f();
} catch (const ApiError&) {
}
}
std::vector<molo::llm::ChatChunk> run_stream(ChatStreamParser& parser, const std::string& wire) {
std::vector<molo::llm::ChatChunk> all;
molo::llm::SseDecoder dec("openrouter", [&](const molo::llm::SseEvent& ev) {
for (auto& c : parser.feed(ev)) all.push_back(c);
return true;
});
dec.feed(wire);
dec.finish();
return all;
}
} // namespace
TEST(openrouter, stream_with_heartbeats_tool_calls_reasoning_and_usage) {
// Spec-shaped chunks (schema ChatStreamChunk) with the documented
// ": OPENROUTER PROCESSING" heartbeat comments between them.
const std::string wire =
": OPENROUTER PROCESSING\n\n"
"data: {\"id\":\"gen-1\",\"object\":\"chat.completion.chunk\",\"created\":1,\"model\":\"openai/gpt-4o\",\"provider\":\"OpenAI\",\"choices\":[{\"index\":0,\"delta\":{\"role\":\"assistant\",\"reasoning\":\"think \"},\"finish_reason\":null}]}\n\n"
": OPENROUTER PROCESSING\n\n"
"data: {\"id\":\"gen-1\",\"object\":\"chat.completion.chunk\",\"created\":1,\"model\":\"openai/gpt-4o\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Hel\"},\"finish_reason\":null}]}\n\n"
"data: {\"id\":\"gen-1\",\"object\":\"chat.completion.chunk\",\"created\":1,\"model\":\"openai/gpt-4o\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"lo\",\"tool_calls\":[{\"index\":0,\"id\":\"call_9\",\"type\":\"function\",\"function\":{\"name\":\"get_weather\",\"arguments\":\"{\\\"ci\"}}]},\"finish_reason\":null}]}\n\n"
"data: {\"id\":\"gen-1\",\"object\":\"chat.completion.chunk\",\"created\":1,\"model\":\"openai/gpt-4o\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"ty\\\":\\\"Rome\\\"}\"}}]},\"finish_reason\":\"tool_calls\"}]}\n\n"
"data: {\"id\":\"gen-1\",\"object\":\"chat.completion.chunk\",\"created\":1,\"model\":\"openai/gpt-4o\",\"choices\":[],\"usage\":{\"prompt_tokens\":10,\"completion_tokens\":5,\"total_tokens\":15,\"cost\":0.0001,\"prompt_tokens_details\":{\"cached_tokens\":4},\"completion_tokens_details\":{\"reasoning_tokens\":2}}}\n\n"
"data: [DONE]\n\n";
ChatStreamParser parser;
auto chunks = run_stream(parser, wire);
ChatResult r = parser.result();
ASSERT_FALSE(parser.errored());
ASSERT_EQ(r.id, "gen-1");
ASSERT_EQ(r.provider, "OpenAI");
ASSERT_EQ(r.text(), "Hello");
ASSERT_EQ(r.first().reasoning, "think ");
ASSERT_EQ(r.finish_reason(), "tool_calls");
ASSERT_EQ(r.first().tool_calls.size(), 1u);
ASSERT_EQ(r.first().tool_calls[0].name, "get_weather");
ASSERT_EQ(r.first().tool_calls[0].id, "call_9");
ASSERT_EQ(r.first().tool_calls[0].arguments.find("city")->as_string(), "Rome");
ASSERT_TRUE(r.usage.has_value());
ASSERT_EQ(r.usage->total_tokens, 15);
ASSERT_EQ(r.usage->cached_tokens, 4);
ASSERT_EQ(r.usage->reasoning_tokens, 2);
ASSERT_TRUE(r.cost.has_value());
bool saw_args_without_name = false;
for (const auto& c : chunks)
if (!c.tool_args_delta.empty() && c.tool_call_name.empty() && c.tool_call_id == "call_9") saw_args_without_name = true;
ASSERT_TRUE(saw_args_without_name);
}
TEST(openrouter, mid_stream_error_chunk) {
// docs (errors guide, "Mid-stream errors"), verbatim data line.
const std::string wire =
"data: {\"id\":\"gen-abc123\",\"object\":\"chat.completion.chunk\",\"created\":1234567890,\"model\":\"openai/gpt-4o\",\"provider\":\"OpenAI\",\"error\":{\"code\":429,\"message\":\"Rate limit exceeded\",\"metadata\":{\"error_type\":\"rate_limit_exceeded\"}},\"choices\":[{\"index\":0,\"delta\":{\"content\":\"\"},\"finish_reason\":\"error\"}]}\n\n";
ChatStreamParser parser;
auto chunks = run_stream(parser, wire);
ASSERT_TRUE(parser.errored());
ASSERT_EQ(parser.error()->code, 429);
ASSERT_EQ(parser.error()->error_type, "rate_limit_exceeded");
int error_finishes = 0;
for (const auto& c : chunks)
if (c.finish_reason == "error") ++error_finishes;
ASSERT_EQ(error_finishes, 1);
try {
parser.throw_if_errored();
FAIL("expected ApiError");
} catch (const ApiError& e) {
ASSERT_EQ(e.http_status(), 429);
ASSERT_EQ(e.type(), "rate_limit_exceeded");
ASSERT_TRUE(describe(e).kind == FailureKind::kRateLimited);
ASSERT_TRUE(describe(e).retryable);
}
}
TEST(openrouter, responses_and_messages_stream_parsers) {
ResponsesStreamParser rp;
auto feed = [](auto& parser, const std::string& type, const std::string& json) {
molo::llm::SseEvent ev;
ev.event = type;
ev.data = Json::parse(json);
return parser.feed(ev);
};
ASSERT_EQ(feed(rp, "response.output_text.delta", "{\"type\":\"response.output_text.delta\",\"delta\":\"Hi\"}"), "Hi");
feed(rp, "response.completed",
"{\"type\":\"response.completed\",\"response\":{\"id\":\"resp_1\",\"status\":\"completed\",\"usage\":{\"input_tokens\":100,\"input_tokens_details\":{\"cached_tokens\":0},\"output_tokens\":50,\"output_tokens_details\":{\"reasoning_tokens\":0},\"total_tokens\":150}}}");
ASSERT_EQ(rp.summary().text, "Hi");
ASSERT_EQ(rp.summary().status, "completed");
ASSERT_EQ(rp.summary().usage->total_tokens, 150);
rp.throw_if_errored(); // no error
// docs (errors guide): a failed Responses stream keeps error_type at top level.
ResponsesStreamParser failed;
feed(failed, "response.failed",
"{\"type\":\"response.failed\",\"response\":{\"id\":\"resp_abc123\",\"status\":\"failed\",\"error\":{\"code\":\"server_error\",\"message\":\"Internal server error\"},\"error_type\":\"server\"}}");
ASSERT_THROW(failed.throw_if_errored(), ApiError);
ASSERT_EQ(failed.summary().error->error_type, "server");
MessagesStreamParser mp;
feed(mp, "message_start", "{\"type\":\"message_start\",\"message\":{\"id\":\"msg_1\",\"model\":\"anthropic/claude\"}}");
ASSERT_EQ(feed(mp, "content_block_delta", "{\"type\":\"content_block_delta\",\"delta\":{\"type\":\"text_delta\",\"text\":\"Yo\"}}"), "Yo");
feed(mp, "message_delta", "{\"type\":\"message_delta\",\"delta\":{\"stop_reason\":\"end_turn\"},\"usage\":{\"output_tokens\":15}}");
ASSERT_EQ(mp.summary().status, "end_turn");
ASSERT_EQ(mp.summary().usage->output_tokens, 15);
// spec example of MessagesErrorEvent
feed(mp, "error", "{\"type\":\"error\",\"error\":{\"error_type\":\"provider_overloaded\",\"message\":\"Overloaded\",\"type\":\"overloaded_error\"}}");
try {
mp.throw_if_errored();
FAIL("expected ApiError");
} catch (const ApiError& e) {
ASSERT_EQ(e.http_status(), 503);
ASSERT_EQ(e.type(), "provider_overloaded");
}
}
TEST(openrouter, error_semantics) {
ASSERT_TRUE(classify_status(402) == FailureKind::kCredits);
ASSERT_FALSE(failure_retryable(FailureKind::kCredits));
ASSERT_TRUE(failure_retryable(classify_status(502)));
ASSERT_TRUE(failure_retryable(classify_status(503)));
ASSERT_TRUE(classify_status(529) == FailureKind::kOverloaded);
ASSERT_EQ(status_for_error_type("context_length_exceeded"), 400);
ASSERT_TRUE(is_known_error_type("provider_unavailable"));
ASSERT_FALSE(is_known_error_type("made_up"));
// docs: guardrail 403 body
Json doc = Json::parse("{\"error\":{\"code\":403,\"message\":\"Request blocked: prompt injection patterns detected\",\"metadata\":{\"patterns\":[\"ignore all previous instructions\"]}}}");
try {
throw_if_error_body(doc);
FAIL("expected ApiError");
} catch (const ApiError& e) {
ASSERT_EQ(e.http_status(), 403);
ASSERT_TRUE(describe(e).kind == FailureKind::kForbidden);
}
throw_if_error_body(Json::parse("{\"choices\":[]}")); // no error: no throw
// A 200 whose only content is an error is rejected by ChatResult::parse too.
ASSERT_THROW(ChatResult::parse(doc), ApiError);
ASSERT_THROW(ChatResult::parse(Json::parse("{\"choices\":[{\"index\":0,\"finish_reason\":\"error\",\"message\":{\"role\":\"assistant\",\"content\":\"partial\"}}]}")), ApiError);
ChatResult ok = ChatResult::parse(Json::parse("{\"id\":\"gen-2\",\"model\":\"m\",\"choices\":[{\"index\":0,\"finish_reason\":\"stop\",\"message\":{\"role\":\"assistant\",\"content\":\"yo\",\"reasoning\":\"r\"}}],\"usage\":{\"prompt_tokens\":1,\"completion_tokens\":2,\"total_tokens\":3}}"));
ASSERT_EQ(ok.text(), "yo");
ASSERT_EQ(ok.first().reasoning, "r");
ASSERT_EQ(ok.usage->output_tokens, 2);
Json bad_args = parse_tool_arguments("{not json");
ASSERT_TRUE(bad_args.has("_invalid_arguments"));
}
TEST(openrouter, key_routing_and_attribution_headers) {
Rig r;
swallow([&] { AccountService(r.gateway).credits(); });
ASSERT_EQ(r.mgmt_t->send_count(), 1u);
ASSERT_EQ(r.api_t->send_count(), 0u);
auto seen = r.mgmt_t->seen()[0];
ASSERT_EQ(seen.headers.get_or("Authorization", ""), "Bearer MGMTKEY");
ASSERT_EQ(seen.target, "/api/v1/credits");
ASSERT_EQ(seen.headers.get_or("HTTP-Referer", ""), "https://myapp.example");
ASSERT_EQ(seen.headers.get_or("X-OpenRouter-Title", ""), "My App");
ASSERT_EQ(seen.headers.get_or("X-Title", ""), "My App");
ASSERT_EQ(seen.headers.get_or("X-OpenRouter-Categories", ""), "cli-agent,cloud-agent");
ASSERT_EQ(seen.headers.get_or("X-OpenRouter-Metadata", ""), "enabled");
swallow([&] { AccountService(r.gateway).key_info(); });
ASSERT_EQ(r.api_t->send_count(), 1u);
ASSERT_EQ(r.api_t->seen()[0].headers.get_or("Authorization", ""), "Bearer APIKEY");
swallow([&] { ModelsService(r.gateway).count(); });
ASSERT_EQ(r.anon_t->send_count(), 1u);
ASSERT_EQ(r.anon_t->seen()[0].headers.get_or("Authorization", ""), "");
ASSERT_EQ(r.anon_t->seen()[0].target, "/api/v1/models/count");
swallow([&] { ProvidersService(r.gateway).list(); });
ASSERT_EQ(r.anon_t->seen()[1].target, "/api/v1/providers");
// Chat body reaches the inference key, with the keys never in the target.
ChatService chat(r.gateway);
swallow([&] { chat.create(ChatParams::simple("openai/gpt-4o", "hi")); });
auto c = r.api_t->seen()[1];
ASSERT_EQ(c.target, "/api/v1/chat/completions");
ASSERT_TRUE(c.body.find("\"messages\"") != std::string::npos);
ASSERT_EQ(c.target.find("KEY"), std::string::npos);
}
TEST(openrouter, two_credentials_are_independent) {
Rig no_mgmt("APIKEY", "");
ASSERT_TRUE(no_mgmt.gateway->api_configured());
ASSERT_FALSE(no_mgmt.gateway->management_configured());
KeysService keys(no_mgmt.gateway);
ASSERT_FALSE(keys.ready());
try {
keys.list();
FAIL("expected NotConfiguredError");
} catch (const molo::llm::NotConfiguredError& e) {
ASSERT_EQ(e.http_status(), 503);
ASSERT_TRUE(e.message().find("OPENROUTER_MANAGEMENT_KEY") != std::string::npos);
}
ASSERT_EQ(no_mgmt.mgmt_t->send_count(), 0u);
ASSERT_EQ(no_mgmt.api_t->send_count(), 0u); // the inference key is never used as a fallback
Rig no_api("", "MGMTKEY");
ChatService chat(no_api.gateway);
ASSERT_FALSE(chat.ready());
ASSERT_THROW(chat.create(ChatParams::simple("a/b", "x")), molo::llm::NotConfiguredError);
ASSERT_TRUE(ModelsService(no_api.gateway).ready()); // public listing needs no key
}
TEST(openrouter, request_shapes_for_management_calls) {
Rig r;
KeysService keys(r.gateway);
KeyDraft d;
d.name = "ci";
d.limit = 10;
d.limit_reset = "monthly";
d.expires_at = "2027-12-31T23:59:59Z";
swallow([&] { keys.create(d); });
auto s = r.mgmt_t->seen()[0];
ASSERT_EQ(s.method, "POST");
ASSERT_EQ(s.target, "/api/v1/keys");
ASSERT_TRUE(s.body.find("\"limit_reset\":\"monthly\"") != std::string::npos);
d.expires_at = "2027-12-31T23:59Z"; // minute precision is rejected by the API
ASSERT_THROW(d.validate(), ApiError);
d.expires_at = "";
d.limit = -1;
ASSERT_THROW(d.validate(), ApiError);
const std::string hash(64, 'a');
swallow([&] { keys.remove(hash); });
ASSERT_EQ(r.mgmt_t->seen()[1].method, "DELETE");
ASSERT_EQ(r.mgmt_t->seen()[1].target, "/api/v1/keys/" + hash);
ASSERT_THROW(keys.remove("short"), ApiError);
ASSERT_THROW(keys.list(0, 101), ApiError);
KeyUpdate u;
ASSERT_THROW(u.to_json(), ApiError); // nothing to update
u.clear_limit_reset = true;
ASSERT_TRUE(u.to_json().find("limit_reset")->is_null());
WorkspacesService ws(r.gateway);
ASSERT_THROW(ws.set_budget("w1", "yearly", 5), ApiError);
ASSERT_THROW(ws.set_budget("w1", "daily", 0), ApiError);
swallow([&] { ws.set_budget("w1", "lifetime", 5); });
ASSERT_EQ(r.mgmt_t->seen().back().method, "PUT");
ASSERT_EQ(r.mgmt_t->seen().back().target, "/api/v1/workspaces/w1/budgets/lifetime");
GuardrailsService g(r.gateway);
ASSERT_THROW(g.assign_keys("g1", {"nothex"}), ApiError);
ASSERT_THROW(g.assign_keys("g1", {}), ApiError);
Json no_name = Json::object();
no_name.set("description", Json("d"));
ASSERT_THROW(g.create(no_name), ApiError);
VaultService vault(r.gateway);
ASSERT_THROW(vault.put_secret("S", "v", {"https://x.example/"}), ApiError);
ASSERT_THROW(vault.put_secret("S", "", {"x.example"}), ApiError);
swallow([&] { vault.put_secret("S", "value", {"x.example"}); });
ASSERT_EQ(r.api_t->seen().back().headers.get_or("Authorization", ""), "Bearer APIKEY");
}
TEST(openrouter, account_parsing_and_filters) {
// OpenAPI example of GET /key (trimmed) and GET /credits.
KeyInfo k = KeyInfo::parse(Json::parse("{\"data\":{\"label\":\"sk-or-v1-au7...890\",\"limit\":100,\"limit_remaining\":74.5,\"limit_reset\":\"monthly\",\"usage\":25.5,\"usage_daily\":25.5,\"is_free_tier\":false,\"is_management_key\":false,\"include_byok_in_limit\":false,\"free_model_daily_requests\":{\"limit\":50,\"remaining\":38,\"used\":12}}}"));
ASSERT_EQ(*k.limit, 100.0);
ASSERT_EQ(*k.limit_remaining, 74.5);
ASSERT_EQ(k.limit_reset, "monthly");
ASSERT_EQ(k.free_model_daily_requests.find("remaining")->as_int(), 38);
Credits c = Credits::parse(Json::parse("{\"data\":{\"total_credits\":100.5,\"total_usage\":25.75}}"));
ASSERT_EQ(c.remaining(), 74.75);
ASSERT_THROW(Credits::parse(Json::parse("{}")), ApiError);
ActivityFilter a;
a.date = "2026-10-01";
ASSERT_EQ(a.to_query().items().size(), 1u);
a.date = "10/01";
ASSERT_THROW(a.validate(), ApiError);
a.date = "";
a.api_key_hash = "xyz";
ASSERT_THROW(a.validate(), ApiError);
ModelFilter f;
f.output_modalities = {"text", "image"};
f.sort = "newest";
f.limit = 5;
f.zdr = true;
f.max_price = 2.5;
f.supported_parameters = {"tools", "reasoning"};
CallPlanner::plan("getModels", {}, f.to_query()); // every key is declared
ASSERT_EQ(f.to_query().items().size(), 6u);
f.limit = 1001;
ASSERT_THROW(f.validate(), ApiError);
f.limit = 5;
f.sort = "best";
ASSERT_THROW(f.validate(), ApiError);
f.sort = "";
f.min_tool_success_rate = 1.5;
ASSERT_THROW(f.validate(), ApiError);
f = ModelFilter();
f.min_price = 5;
f.max_price = 1;
ASSERT_THROW(f.validate(), ApiError);
// docs: shapes seen on GET /models (pricing values are strings).
ModelInfo m = ModelInfo::parse(Json::parse("{\"id\":\"a/b:free\",\"name\":\"B\",\"context_length\":1000,\"architecture\":{\"modality\":\"text->text\",\"input_modalities\":[\"text\"],\"output_modalities\":[\"text\"]},\"pricing\":{\"prompt\":\"0.000002\",\"completion\":\"0\"},\"supported_parameters\":[\"tools\"]}"));
ASSERT_TRUE(m.supports("tools"));
ASSERT_TRUE(m.is_free());
ASSERT_EQ(*m.price_per_million("prompt"), 2.0);
EndpointInfo e = EndpointInfo::parse(Json::parse("{\"name\":\"Azure | openai/gpt-4o\",\"provider_name\":\"Azure\",\"tag\":\"azure\",\"quantization\":\"unknown\",\"context_length\":128000,\"status\":0,\"uptime_last_30m\":100,\"latency_last_30m\":null}"));
ASSERT_EQ(e.tag, "azure");
ASSERT_EQ(*e.uptime_last_30m, 100.0);
ASSERT_THROW(ModelsService(Rig().gateway).get("nogood"), ApiError);
}
TEST(openrouter, pkce_and_auth) {
// RFC 7636 appendix B; the OpenAPI example of /auth/keys uses the same pair.
PkcePair p = PkcePair::from_verifier("dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk");
ASSERT_EQ(p.challenge, "E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM");
ASSERT_THROW(PkcePair::from_verifier("short"), ApiError);
ASSERT_THROW(PkcePair::from_verifier(std::string(43, '!')), ApiError);
PkcePair g = PkcePair::generate();
ASSERT_TRUE(g.verifier.size() >= 43 && g.verifier.size() <= 128);
ASSERT_TRUE(g.verifier != PkcePair::generate().verifier);
std::string url = AuthService::authorization_url("https://myapp.com/cb", p);
ASSERT_TRUE(url.find("https://openrouter.ai/auth?callback_url=https%3A%2F%2Fmyapp.com%2Fcb") == 0);
ASSERT_TRUE(url.find("code_challenge=E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM&code_challenge_method=S256") != std::string::npos);
ASSERT_THROW(AuthService::authorization_url("http://evil.example/cb", p), ApiError);
Rig r;
AuthService auth(r.gateway);
swallow([&] { auth.exchange_code("auth_code_abc123def456", p.verifier); });
ASSERT_EQ(r.anon_t->send_count(), 1u); // the exchange needs no key
ASSERT_EQ(r.anon_t->seen()[0].target, "/api/v1/auth/keys");
ASSERT_TRUE(r.anon_t->seen()[0].body.find("\"code_challenge_method\":\"S256\"") != std::string::npos);
swallow([&] { auth.exchange_token("pol", "tok", "urn:ietf:params:oauth:token-type:jwt"); });
ASSERT_EQ(r.anon_t->seen()[1].headers.get_or("Content-Type", ""), "application/x-www-form-urlencoded");
}
TEST(openrouter, chat_model_mapping) {
Rig r;
ChatModelDefaults d;
d.provider = ProviderPreferences::only_providers({"openai"});
d.fallback_models = {"anthropic/claude-3.5-sonnet"};
d.plugins = {std::make_shared<ResponseHealingPlugin>()};
OpenrouterChatModel model(r.gateway, "openai/gpt-4o", d);
ASSERT_EQ(model.vendor(), "openrouter");
molo::llm::ChatRequest req;
req.system = "be brief";
req.messages.push_back(molo::llm::Message::user("weather?"));
molo::llm::Message a;
a.role = molo::llm::Role::kAssistant;
molo::llm::ToolCall call;
call.id = "c1";
call.name = "get_weather";
call.arguments.set("city", Json("Rome"));
a.parts.push_back(molo::llm::ContentPart::of_call(call));
req.messages.push_back(a);
molo::llm::Message t;
t.role = molo::llm::Role::kTool;
t.parts.push_back(molo::llm::ContentPart::of_result({"c1", "sunny", false}));
req.messages.push_back(t);
molo::llm::ToolSpec spec;
spec.name = "get_weather";
spec.description = "weather";
req.tools.push_back(spec);
req.tool_choice = "get_weather";
req.max_tokens = 50;
req.temperature = 0.2;
req.reasoning_effort = "low";
req.response_schema = Json::object();
Json body = model.to_body(req);
ASSERT_EQ(body.find("model")->as_string(), "openai/gpt-4o");
ASSERT_EQ(body.find("models")->as_array().size(), 1u);
ASSERT_EQ(body.find("provider")->find("only")->as_array()[0].as_string(), "openai");
ASSERT_EQ(body.find("plugins")->as_array()[0].find("id")->as_string(), "response-healing");
ASSERT_EQ(body.find("reasoning")->find("effort")->as_string(), "low");
ASSERT_EQ(body.find("response_format")->find("type")->as_string(), "json_schema");
ASSERT_EQ(body.find("tool_choice")->find("function")->find("name")->as_string(), "get_weather");
const auto& msgs = body.find("messages")->as_array();
ASSERT_EQ(msgs.size(), 4u);
ASSERT_EQ(msgs[0].find("role")->as_string(), "system");
ASSERT_EQ(msgs[2].find("tool_calls")->as_array()[0].find("function")->find("arguments")->as_string(), "{\"city\":\"Rome\"}");
ASSERT_EQ(msgs[3].find("role")->as_string(), "tool");
ASSERT_EQ(msgs[3].find("tool_call_id")->as_string(), "c1");
req.extra = Json::object();
req.extra.set("session_id", Json("s"));
ASSERT_EQ(model.to_body(req).find("session_id")->as_string(), "s");
req.extra.set("bogus", Json(1));
ASSERT_THROW(model.to_body(req), ApiError);
swallow([&] { model.generate(molo::llm::ChatRequest{}); });
ASSERT_EQ(r.api_t->send_count(), 0u); // empty messages are rejected before the network
ChatResult parsed = ChatResult::parse(Json::parse("{\"id\":\"gen-9\",\"model\":\"m\",\"choices\":[{\"index\":0,\"finish_reason\":\"tool_calls\",\"message\":{\"role\":\"assistant\",\"content\":null,\"tool_calls\":[{\"id\":\"c\",\"type\":\"function\",\"function\":{\"name\":\"f\",\"arguments\":\"{}\"}}]}}]}"));
molo::llm::ChatResponse resp = OpenrouterChatModel::to_response(parsed);
ASSERT_EQ(resp.tool_calls().size(), 1u);
ASSERT_EQ(resp.finish_reason, "tool_calls");
}