Merge branch 'worktree-agent-a1d8c9d17ebff3c74'

This commit is contained in:
2026-10-25 15:24:27 +01:00
52 changed files with 7201 additions and 3 deletions
+33
View File
@@ -0,0 +1,33 @@
// Routes: GET /ai/perplexity (page), /status, /calls, /errors (no credential needed)
#include <cstdlib>
#include "support/Assert.hpp"
using namespace molo::example::test;
int main() {
setenv("MOLO_ENV_FILES", "off", 1);
unsetenv("PERPLEXITY_API_KEY");
Fixture f;
auto page = f.client->get("/ai/perplexity");
check(page.status == 200, "page 200");
check(contains(page.headers.get("Content-Type"), "text/html"), "html");
check(contains(page.body, "Perplexity API") && contains(page.body, "viewport"), "title and mobile viewport");
check(contains(page.body, "/embedded/ai_perplexity.js"), "script wired");
check(f.client->post("/ai/perplexity", "{}", "application/json").status == 405, "post page is 405");
auto st = f.client->get("/ai/perplexity/status");
check(st.status == 200 && contains(st.body, "\"configured\":false"), "status without a key");
check(contains(st.body, "PERPLEXITY_API_KEY") && contains(st.body, "sonar-pro") && contains(st.body, "sonar-deep-research"),
"status names credential env and models");
check(f.client->post("/ai/perplexity/status", "{}", "application/json").status == 405, "post status is 405");
auto calls = f.client->get("/ai/perplexity/calls");
check(calls.status == 200 && contains(calls.body, "/v1/sonar") && contains(calls.body, "/search") &&
contains(calls.body, "/v1/agent") && contains(calls.body, "/orchestrator/v1/chat/completions"),
"call table listed");
auto errors = f.client->get("/ai/perplexity/errors");
check(errors.status == 200 && contains(errors.body, "Payment Required") && contains(errors.body, "\"retryable\":true"),
"error table listed");
return finish("ai/perplexity/page");
}
+105
View File
@@ -0,0 +1,105 @@
// Routes: POST /ai/perplexity/* (405, 422, dry runs, 503 without a credential)
#include <cstdlib>
#include "support/Assert.hpp"
using namespace molo::example::test;
int main() {
setenv("MOLO_ENV_FILES", "off", 1);
unsetenv("PERPLEXITY_API_KEY");
Fixture f;
auto post = [&](const std::string& route, const std::string& body) {
return f.client->post("/ai/perplexity/" + route, body, "application/json");
};
const char* all[] = {"sonar", "stream", "async", "search", "embeddings", "agent", "orchestrator",
"decisions", "models", "usage", "batches", "skills"};
for (const char* r : all) {
std::string route = std::string("/ai/perplexity/") + r;
check(f.client->get(route).status == 405, route + " get is 405");
check(post(r, "not json").status == 422, route + " bad json is 422");
check(post(r, "[1]").status == 422, route + " non-object is 422");
}
// 422: input rules run before anything else
check(post("sonar", "{}").status == 422, "sonar needs prompt");
check(post("sonar", "{\"prompt\":\"hi\",\"max_tokens\":0}").status == 422, "max_tokens 0");
check(post("sonar", "{\"prompt\":\"hi\",\"temperature\":3}").status == 422, "temperature over 2");
check(post("sonar", "{\"prompt\":\"hi\",\"search_mode\":\"dark\"}").status == 422, "bad search_mode");
check(post("sonar", "{\"prompt\":\"hi\",\"search_after_date_filter\":\"2025-01-01\"}").status == 422, "bad date format");
check(post("sonar", "{\"prompt\":\"hi\",\"json_schema\":[1]}").status == 422, "schema must be object");
check(post("async", "{\"action\":\"fly\"}").status == 422, "bad async action");
check(post("async", "{\"action\":\"get\",\"id\":\"../x\"}").status == 422, "bad async id");
check(post("search", "{\"query\":\" \"}").status == 422, "blank query");
check(post("search", "{\"query\":\"x\",\"max_results\":21}").status == 422, "max_results over 20");
check(post("search", "{\"queries\":[\"1\",\"2\",\"3\",\"4\",\"5\",\"6\"]}").status == 422, "more than 5 queries");
check(post("embeddings", "{}").status == 422, "embeddings need input");
check(post("embeddings", "{\"input\":[\"x\"],\"dimensions\":64}").status == 422, "dimensions under 128");
check(post("embeddings", "{\"documents\":[[]]}").status == 422, "empty document");
check(post("agent", "{}").status == 422, "agent needs input");
check(post("agent", "{\"input\":\"x\",\"model\":\"anthropic/claude-sonnet-5-5\"}").status == 422, "anthropic models need max_output_tokens");
check(post("agent", "{\"input\":\"x\",\"tools\":[\"telepathy\"]}").status == 422, "unknown tool");
check(post("agent", "{\"action\":\"get\",\"id\":\"a/b\"}").status == 422, "bad agent id");
check(post("orchestrator", "{\"model\":\"kimi\",\"prompt\":\"x\"}").status == 422, "model needs a creator prefix");
check(post("orchestrator", "{\"api\":\"graphql\",\"model\":\"a/b\",\"prompt\":\"x\"}").status == 422, "bad orchestrator api");
check(post("decisions", "{\"state\":\"x\"}").status == 422, "decisions need questions");
check(post("models", "{\"kind\":\"other\"}").status == 422, "bad models kind");
check(post("usage", "{}").status == 422, "usage needs dataset");
check(post("usage", "{\"dataset\":\"query_volume\",\"bucket_width\":\"1h\",\"start_time\":1}").status == 422, "daily-only dataset rejects 1h");
check(post("batches", "{\"action\":\"upload\",\"jsonl\":\"not json\"}").status == 422, "bad jsonl");
check(post("batches", "{\"action\":\"get\",\"id\":\"../x\"}").status == 422, "bad batch id");
check(post("skills", "{\"action\":\"delete\",\"id\":\"skill_1\"}").status == 422, "delete needs expected_revision");
check(post("skills", "{\"action\":\"create\",\"data_base64\":\"aGVsbG8=\"}").status == 422, "not a zip");
check(post("skills", "{\"action\":\"create\",\"data_base64\":\"@@\"}").status == 422, "bad base64");
// dry runs: paid or resource-changing routes show the exact request
auto dry = post("sonar", "{\"prompt\":\"hi\",\"model\":\"sonar-pro\",\"search_mode\":\"academic\"}");
check(dry.status == 200 && contains(dry.body, "\"dry_run\":true") && contains(dry.body, "\"model\":\"sonar-pro\"") &&
contains(dry.body, "/v1/sonar") && contains(dry.body, "\"search_mode\":\"academic\""),
"sonar is a dry run without confirm");
check(contains(post("stream", "{\"prompt\":\"hi\"}").body, "\"stream\":true"), "stream preview");
check(contains(post("async", "{\"action\":\"create\",\"prompt\":\"hi\",\"model\":\"sonar-deep-research\"}").body, "/v1/async/sonar"),
"async create is a dry run");
check(contains(post("search", "{\"query\":\"x\"}").body, "\"dry_run\":true"), "search is a dry run");
check(contains(post("embeddings", "{\"input\":[\"x\"]}").body, "/v1/embeddings"), "embeddings dry run");
check(contains(post("embeddings", "{\"documents\":[[\"a\",\"b\"]]}").body, "/v1/contextualizedembeddings"), "contextualized dry run");
check(contains(post("agent", "{\"input\":\"x\",\"tools\":[\"web_search\"]}").body, "\"type\":\"web_search\""), "agent dry run shows tools");
check(contains(post("agent", "{\"action\":\"cancel\",\"id\":\"resp_1\"}").body, "\"dry_run\":true"), "cancel is a dry run");
check(contains(post("orchestrator", "{\"model\":\"perplexity/kimi-k3\",\"prompt\":\"x\"}").body, "/orchestrator/v1/chat/completions"),
"orchestrator dry run");
check(contains(post("decisions", "{\"state\":\"x\",\"questions\":{\"q\":{\"type\":\"noul\",\"instructions\":\"?\"}}}").body, "\"dry_run\":true"),
"decisions dry run");
check(contains(post("batches", "{\"action\":\"create\",\"input_file_id\":\"file_1\"}").body, "\"dry_run\":true"), "batch create dry run");
check(contains(post("batches", "{\"action\":\"cancel\",\"id\":\"batch_1\"}").body, "\"dry_run\":true"), "batch cancel dry run");
check(contains(post("batches", "{\"action\":\"file_delete\",\"id\":\"file_1\"}").body, "\"dry_run\":true"), "file delete dry run");
check(contains(post("batches", "{\"action\":\"upload\",\"jsonl\":\"{\\\"custom_id\\\":\\\"1\\\"}\"}").body, "\"dry_run\":true"), "upload dry run");
check(contains(post("skills", "{\"action\":\"delete\",\"id\":\"skill_1\",\"expected_revision\":\"r1\"}").body, "\"dry_run\":true"), "skill delete dry run");
check(contains(post("skills", "{\"action\":\"create\",\"data_base64\":\"UEsDBHJlc3Q=\"}").body, "\"dry_run\":true"), "skill create dry run");
// 503: free calls and confirmed calls need the credential
const char* reads[] = {"{}", "{\"kind\":\"orchestrator\"}"};
for (const char* body : reads) {
auto res = post("models", body);
check(res.status == 503 && contains(res.body, "perplexity_not_configured"), "models without key is 503");
}
check(post("usage", "{\"dataset\":\"credit_usage\",\"start_time\":1}").status == 503, "usage without key is 503");
check(post("usage", "{\"dataset\":\"credit_usage\",\"start_time\":1,\"per_member\":true}").status == 503, "per member usage without key is 503");
check(post("async", "{\"action\":\"list\"}").status == 503, "async list without key is 503");
check(post("async", "{\"action\":\"get\",\"id\":\"req_1\"}").status == 503, "async get without key is 503");
check(post("agent", "{\"action\":\"get\",\"id\":\"resp_1\"}").status == 503, "agent get without key is 503");
check(post("agent", "{\"action\":\"files\",\"id\":\"resp_1\"}").status == 503, "agent files without key is 503");
check(post("batches", "{\"action\":\"list\"}").status == 503, "batches list without key is 503");
check(post("batches", "{\"action\":\"files\"}").status == 503, "batch files without key is 503");
check(post("skills", "{\"action\":\"list\"}").status == 503, "skills list without key is 503");
check(post("sonar", "{\"prompt\":\"hi\",\"confirm\":true}").status == 503, "confirmed sonar without key is 503");
check(post("stream", "{\"prompt\":\"hi\",\"confirm\":true}").status == 503, "confirmed stream without key is 503");
check(post("search", "{\"query\":\"x\",\"confirm\":true}").status == 503, "confirmed search without key is 503");
check(post("embeddings", "{\"input\":[\"x\"],\"confirm\":true}").status == 503, "confirmed embeddings without key is 503");
check(post("agent", "{\"input\":\"x\",\"confirm\":true}").status == 503, "confirmed agent without key is 503");
check(post("orchestrator", "{\"model\":\"a/b\",\"prompt\":\"x\",\"confirm\":true}").status == 503, "confirmed orchestrator without key is 503");
check(post("decisions", "{\"state\":\"x\",\"questions\":{\"q\":{\"type\":\"noul\",\"instructions\":\"?\"}},\"confirm\":true}").status == 503,
"confirmed decisions without key is 503");
check(post("skills", "{\"action\":\"delete\",\"id\":\"skill_1\",\"expected_revision\":\"r1\",\"confirm\":true}").status == 503,
"confirmed skill delete without key is 503");
check(post("batches", "{\"action\":\"cancel\",\"id\":\"b1\",\"confirm\":true}").status == 503, "confirmed batch cancel without key is 503");
return finish("ai/perplexity/routes");
}
+52
View File
@@ -0,0 +1,52 @@
#pragma once
// Shared rig for the Perplexity tests: a Platform over a MockTransport with a
// fake key. The mock only records the requests the real client builds; replies
// are fixtures labelled where they appear: FIXTURE (verbatim from the
// Perplexity docs) or SCHEMA (shape taken from the OpenAPI schema, values
// invented). Nothing here verifies vendor behavior (see
// src/vendors/perplexity/SPEC.md ## Unverified).
#include <memory>
#include <string>
#include "clients/transports/mock_transport.h"
#include "framework.h"
#include "vendors/perplexity/platform.h"
namespace perplexity_test {
using molo::clients::ClientResponse;
using molo::clients::HeaderMap;
using molo::clients::Method;
using molo::clients::transports::MockExpectation;
using molo::clients::transports::MockTransport;
using Json = molo::clients::body::Json;
inline ClientResponse reply(const std::string& body, int status = 200,
const std::string& type = "application/json") {
HeaderMap h;
h.set("Content-Type", type);
return ClientResponse(status, h, body);
}
inline ClientResponse sse(const std::string& body) { return reply(body, 200, "text/event-stream"); }
inline bool has(const std::string& hay, const std::string& needle) { return hay.find(needle) != std::string::npos; }
inline const char* kKey = "pplx-TESTKEY-DO-NOT-LEAK";
struct Rig {
MockTransport* transport = nullptr;
molo::perplexity::Platform platform;
explicit Rig(const std::string& key = kKey) {
auto t = std::make_unique<MockTransport>();
transport = t.get();
platform = molo::perplexity::Platform::with(std::move(t), key);
}
std::shared_ptr<molo::llm::ApiClient> client() const { return platform.client; }
MockTransport::SeenRequest last() const { return transport->seen().back(); }
};
} // namespace perplexity_test
+228
View File
@@ -0,0 +1,228 @@
// Agent API: create, stream, background, retrieve, cancel, files, tools.
#include "support.h"
#include "vendors/perplexity/agent.h"
using namespace molo::perplexity;
using namespace perplexity_test;
using molo::llm::ApiError;
namespace {
// SCHEMA: ResponsesResponse with message (annotations), search_results, function_call, usage.cost
const char* kResponse =
"{\"id\":\"resp_1\",\"object\":\"response\",\"created_at\":1760000000,\"status\":\"completed\",\"model\":\"openai/gpt-5.6-terra\",\"effort\":\"fast@2026-09-29.0\","
"\"output\":["
"{\"type\":\"search_results\",\"queries\":[\"capital of france\"],\"results\":[{\"id\":1,\"url\":\"https://example.com/a\",\"title\":\"A\",\"snippet\":\"s\",\"source\":\"web\",\"date\":\"2025-01-01\"}]},"
"{\"type\":\"message\",\"id\":\"msg_1\",\"status\":\"completed\",\"role\":\"assistant\",\"content\":[{\"type\":\"output_text\",\"text\":\"Paris [1].\","
"\"annotations\":[{\"type\":\"url_citation\",\"url\":\"https://example.com/a\",\"title\":\"A\",\"start_index\":6,\"end_index\":9}]}]},"
"{\"type\":\"function_call\",\"id\":\"fc_1\",\"status\":\"completed\",\"call_id\":\"call_1\",\"name\":\"get_time\",\"arguments\":\"{\\\"tz\\\":\\\"UTC\\\"}\"}],"
"\"usage\":{\"input_tokens\":100,\"output_tokens\":20,\"total_tokens\":120,\"input_tokens_details\":{\"cached_tokens\":40},"
"\"cost\":{\"currency\":\"USD\",\"input_cost\":0.001,\"output_cost\":0.002,\"tool_calls_cost\":0.005,\"total_cost\":0.008}}}";
// Event names from the OpenAPI EventType enum; payload keys from the event schemas.
const char* kStream =
"event: response.created\ndata: {\"type\":\"response.created\",\"sequence_number\":0,\"response\":{\"id\":\"resp_s\",\"object\":\"response\",\"status\":\"in_progress\",\"model\":\"m\",\"created_at\":1,\"output\":[]}}\n\n"
": keep-alive\n\n"
"event: response.reasoning.search_queries\ndata: {\"type\":\"response.reasoning.search_queries\",\"sequence_number\":1,\"queries\":[\"q1\"],\"thought\":\"searching\"}\n\n"
"event: response.reasoning.search_results\ndata: {\"type\":\"response.reasoning.search_results\",\"sequence_number\":2,\"results\":[{\"id\":1,\"url\":\"https://example.com/a\",\"title\":\"A\",\"snippet\":\"s\"}]}\n\n"
"event: response.output_text.delta\ndata: {\"type\":\"response.output_text.delta\",\"sequence_number\":3,\"item_id\":\"msg_1\",\"output_index\":0,\"content_index\":0,\"delta\":\"Hel\"}\n\n"
"event: response.output_text.delta\ndata: {\"type\":\"response.output_text.delta\",\"sequence_number\":4,\"item_id\":\"msg_1\",\"output_index\":0,\"content_index\":0,\"delta\":\"lo\"}\n\n"
"event: response.completed\ndata: {\"type\":\"response.completed\",\"sequence_number\":5,\"response\":{\"id\":\"resp_s\",\"object\":\"response\",\"status\":\"completed\",\"model\":\"m\",\"created_at\":1,"
"\"output\":[{\"type\":\"message\",\"id\":\"msg_1\",\"status\":\"completed\",\"role\":\"assistant\",\"content\":[{\"type\":\"output_text\",\"text\":\"Hello\"}]}],"
"\"usage\":{\"input_tokens\":5,\"output_tokens\":2,\"total_tokens\":7}}}\n\n"
"data: [DONE]\n\n";
} // namespace
TEST(perplexity_agent, create_with_tools_skills_and_parse_every_accessor) {
Rig rig;
rig.transport->expect_response(Method::kPost, "/v1/agent", reply(kResponse));
Agent agent(rig.client());
AgentParams p = AgentParams::prompt("Capital of France?", "openai/gpt-5.6-terra");
p.instructions = "Be brief.";
WebSearchToolOptions ws;
ws.max_results = 5;
ws.search_recency_filter = "week";
ws.search_domain_filter = {"example.com"};
p.tools = {AgentTools::web_search(ws), AgentTools::fetch_url(3), AgentTools::sandbox(),
AgentTools::function("get_time", "time", Json::parse("{\"type\":\"object\",\"properties\":{}}"), true)};
p.tool_choice = AgentTools::choice("auto");
p.skills = {AgentSkills::builtin("office/pdf"), AgentSkills::custom("skill_abc", "latest")};
p.max_steps = 12;
p.reasoning_effort = "high";
AgentResult r = agent.create(p);
ASSERT_EQ(r.id, "resp_1");
ASSERT_EQ(r.status, "completed");
ASSERT_TRUE(r.finished());
ASSERT_TRUE(r.succeeded());
ASSERT_EQ(r.effort, "fast@2026-09-29.0");
ASSERT_EQ(r.output_text(), "Paris [1].");
ASSERT_EQ(r.citations().size(), 1u);
ASSERT_EQ(r.citations()[0].end_index, 9L);
ASSERT_EQ(r.search_results().size(), 1u);
ASSERT_EQ(r.search_results()[0].id, 1L);
ASSERT_EQ(r.queries()[0], "capital of france");
ASSERT_EQ(r.function_calls().size(), 1u);
ASSERT_TRUE(r.function_calls()[0].arguments_valid());
ASSERT_EQ(r.function_calls()[0].parsed().find("tz")->as_string(), "UTC");
ASSERT_EQ(r.usage.input_tokens, 100L);
ASSERT_EQ(r.usage.cached_tokens, 40L);
ASSERT_EQ(r.usage.cost.tool_calls, 0.005);
ASSERT_EQ(r.usage.cost.currency, "USD");
auto s = rig.last();
ASSERT_TRUE(has(s.body, "\"model\":\"openai/gpt-5.6-terra\""));
ASSERT_TRUE(has(s.body, "\"type\":\"web_search\""));
ASSERT_TRUE(has(s.body, "\"filters\":{\"search_domain_filter\":[\"example.com\"],\"search_recency_filter\":\"week\"}"));
ASSERT_TRUE(has(s.body, "\"max_urls\":3"));
ASSERT_TRUE(has(s.body, "{\"type\":\"sandbox\"}"));
ASSERT_TRUE(has(s.body, "\"skills\":[{\"name\":\"office/pdf\",\"type\":\"builtin\"},{\"id\":\"skill_abc\",\"type\":\"custom\",\"version\":\"latest\"}]"));
ASSERT_TRUE(has(s.body, "\"reasoning\":{\"effort\":\"high\"}"));
ASSERT_TRUE(has(s.body, "\"tool_choice\":\"auto\""));
ASSERT_FALSE(has(s.body, "\"stream\""));
}
TEST(perplexity_agent, effort_profile_and_fallback_rules) {
Rig rig;
Agent agent(rig.client());
AgentParams p = AgentParams::with_effort("hi", "fast@latest");
p.to_json();
p.profile_id = "prof_1";
ASSERT_THROW(agent.create(p), ApiError); // profile + effort
p.effort.clear();
p.model = "openai/gpt-5.6-terra";
Json b = p.to_json();
ASSERT_EQ(b.find("profile")->find("type")->as_string(), "custom");
p.models = {"a/1", "a/2", "a/3", "a/4", "a/5", "a/6"};
ASSERT_THROW(agent.create(p), ApiError); // more than 5 fallbacks
AgentParams anth = AgentParams::prompt("hi", "anthropic/claude-sonnet-5-5");
ASSERT_THROW(agent.create(anth), ApiError); // max_output_tokens required
anth.max_output_tokens = 1024;
anth.to_json();
ASSERT_EQ(rig.transport->send_count(), 0u);
}
TEST(perplexity_agent, builders_validate_their_inputs) {
WebSearchToolOptions deep;
deep.search_type = "deep";
ASSERT_THROW(AgentTools::web_search(deep), ApiError);
WebSearchToolOptions many;
many.max_results = 51;
ASSERT_THROW(AgentTools::web_search(many), ApiError);
ASSERT_THROW(AgentTools::image_search(31), ApiError);
ASSERT_THROW(AgentTools::fetch_url(11), ApiError);
ASSERT_THROW(AgentTools::mcp("lbl", "http://insecure.example.com"), ApiError);
ASSERT_THROW(AgentTools::mcp("bad label", "https://example.com/mcp"), ApiError);
ASSERT_THROW(AgentTools::choice("sometimes"), ApiError);
ASSERT_THROW(AgentSkills::builtin("office/odt"), ApiError);
ASSERT_THROW(AgentSkills::custom("abc"), ApiError);
ASSERT_THROW(AgentSkills::inline_skill("Bad_Name", "d", "i"), ApiError);
ASSERT_THROW(AgentSkills::inline_skill("ok-name", std::string(1025, 'd'), "i"), ApiError);
ASSERT_THROW(AgentInput::file_part("", ""), ApiError);
ASSERT_THROW(AgentInput::file_part("AAAA", "https://example.com/a.pdf"), ApiError);
ASSERT_THROW(AgentInput::mcp_approval_response("id", true, "because"), ApiError);
AgentTools::mcp("lbl", "https://example.com/mcp", "tok", {"search"}, "always");
AgentParams p = AgentParams::prompt("x", "a/b");
p.skills.assign(17, AgentSkills::builtin("office"));
ASSERT_THROW(p.to_json(), ApiError);
}
TEST(perplexity_agent, stream_folds_events_and_returns_the_completed_response) {
Rig rig;
rig.transport->expect_response(Method::kPost, "/v1/agent", sse(kStream));
Agent agent(rig.client());
std::string text;
std::vector<std::string> types, queries;
AgentResult r = agent.stream(AgentParams::prompt("Hi", "a/b"), [&](const AgentDelta& d) {
text += d.text;
types.push_back(d.type);
for (const std::string& q : d.queries) queries.push_back(q);
return true;
});
ASSERT_EQ(text, "Hello");
ASSERT_EQ(types.size(), 6u); // the keep-alive comment and [DONE] produce no event
ASSERT_EQ(types.front(), "response.created");
ASSERT_EQ(types.back(), "response.completed");
ASSERT_EQ(queries.size(), 1u);
ASSERT_EQ(r.id, "resp_s");
ASSERT_EQ(r.output_text(), "Hello");
ASSERT_EQ(r.usage.total_tokens, 7L);
ASSERT_TRUE(has(rig.last().body, "\"stream\":true"));
}
TEST(perplexity_agent, stream_failure_event_and_truncation) {
Rig rig;
rig.transport->expect_response(
Method::kPost, "/v1/agent",
sse("event: response.failed\ndata: {\"type\":\"response.failed\",\"sequence_number\":1,\"error\":{\"type\":\"server_error\",\"code\":\"x\",\"message\":\"boom\"}}\n\n"));
AgentResult r = Agent(rig.client()).stream(AgentParams::prompt("Hi", "a/b"), nullptr);
ASSERT_EQ(r.status, "failed");
ASSERT_EQ(r.error.message, "boom");
ASSERT_FALSE(r.succeeded());
Rig cut;
cut.transport->expect_response(
Method::kPost, "/v1/agent",
sse("event: response.output_text.delta\ndata: {\"type\":\"response.output_text.delta\",\"sequence_number\":1,\"delta\":\"par\"}\n\n"));
try {
Agent(cut.client()).stream(AgentParams::prompt("Hi", "a/b"), nullptr);
FAIL("expected STREAM_TRUNCATED");
} catch (const ApiError& e) {
ASSERT_EQ(e.type(), "STREAM_TRUNCATED");
}
}
TEST(perplexity_agent, background_get_wait_cancel_and_files) {
Rig rig;
rig.transport->expect_response(Method::kPost, "/v1/agent",
reply("{\"id\":\"resp_b\",\"object\":\"response\",\"status\":\"queued\",\"model\":\"m\",\"created_at\":1,\"output\":[]}"));
Agent agent(rig.client());
AgentResult q = agent.create_background(AgentParams::prompt("long task", "a/b"));
ASSERT_EQ(q.status, "queued");
ASSERT_FALSE(q.finished());
ASSERT_TRUE(has(rig.last().body, "\"background\":true"));
Rig poll;
poll.transport->expect_response(Method::kGet, "/v1/agent/resp_b",
reply("{\"id\":\"resp_b\",\"object\":\"response\",\"status\":\"in_progress\",\"model\":\"m\",\"created_at\":1,\"output\":[],"
"\"paused\":{\"reason\":\"token_rate_limit\",\"window\":\"TPM\",\"estimated_resume_at\":1791302400}}"));
poll.transport->expect_response(Method::kGet, "/v1/agent/resp_b", reply(kResponse));
Agent pagent(poll.client());
int slept = 0;
AgentResult r = pagent.wait("resp_b", 1, 10, [&](int s) { slept += s; });
ASSERT_TRUE(r.succeeded());
ASSERT_EQ(slept, 1);
Rig p2;
p2.transport->expect_response(Method::kGet, "/v1/agent/resp_b",
reply("{\"id\":\"resp_b\",\"object\":\"response\",\"status\":\"in_progress\",\"model\":\"m\",\"created_at\":1,\"output\":[],"
"\"paused\":{\"reason\":\"token_rate_limit\",\"window\":\"TPM\",\"estimated_resume_at\":1791302400}}"));
AgentResult paused = Agent(p2.client()).get("resp_b");
ASSERT_TRUE(paused.has_pause);
ASSERT_EQ(paused.pause.window, "TPM");
ASSERT_EQ(paused.pause.estimated_resume_at, 1791302400L);
Rig c;
c.transport->expect_response(Method::kPost, "/v1/agent/resp_b/cancel", reply("{\"response_id\":\"resp_b\",\"status\":\"cancelling\"}"));
Json cj = Agent(c.client()).cancel("resp_b");
ASSERT_EQ(cj.find("status")->as_string(), "cancelling");
Rig f;
f.transport->expect_response(Method::kGet, "/v1/agent/resp_b/files",
reply("{\"object\":\"list\",\"data\":[{\"id\":\"file_1\",\"object\":\"file\",\"filename\":\"out.csv\",\"bytes\":12,\"created_at\":5}]}"));
f.transport->expect_response(Method::kGet, "/v1/agent/resp_b/files/file_1/content", reply("a,b\n1,2\n", 200, "application/octet-stream"));
Agent fagent(f.client());
AgentFileList fl = fagent.files("resp_b");
ASSERT_EQ(fl.files.size(), 1u);
ASSERT_EQ(fl.files[0].filename, "out.csv");
FileBytes fb = fagent.file_content("resp_b", "file_1");
ASSERT_EQ(fb.data, "a,b\n1,2\n");
ASSERT_EQ(fb.content_type, "application/octet-stream");
}
TEST(perplexity_agent, ids_are_validated_and_wait_has_bounds) {
Rig rig;
Agent agent(rig.client());
ASSERT_THROW(agent.get("../etc"), ApiError);
ASSERT_THROW(agent.cancel("a/b"), ApiError);
ASSERT_THROW(agent.file_content("resp_1", "x?y"), ApiError);
ASSERT_THROW(agent.wait("resp_1", 0, 10), ApiError);
ASSERT_THROW(agent.wait("resp_1", 1, 601), ApiError);
ASSERT_EQ(rig.transport->send_count(), 0u);
}
+75
View File
@@ -0,0 +1,75 @@
// Opt-in live checks. MOLO_LIVE_NET=1 enables the network; PERPLEXITY_API_KEY
// (via llm::Config) enables the read-only calls. MOLO_LIVE_PAID=1 additionally
// allows ONE smallest-possible Sonar completion and one Search. Without them
// each test prints a loud SKIP. Nothing is created or deleted.
#include <cstdlib>
#include <iostream>
#include "clients/transports/http_transport.h"
#include "support.h"
#include "vendors/perplexity/account.h"
#include "vendors/perplexity/search.h"
#include "vendors/perplexity/sonar.h"
using namespace molo::perplexity;
using molo::llm::ApiError;
namespace {
// Read at static-init time: tests/src/llm/test_llm.cpp unsetenv()s MOLO_LIVE_NET mid-run (suite gap).
const bool g_net = std::getenv("MOLO_LIVE_NET") != nullptr;
const bool g_paid = std::getenv("MOLO_LIVE_PAID") != nullptr;
bool net() { return g_net; }
bool paid() { return g_paid; }
} // namespace
// No key needed: a deliberately invalid key must answer 401 with the
// documented error envelope (type invalid_api_key). Recorded 2026-10-25.
TEST(perplexity_live, invalid_key_answers_401_with_the_error_envelope) {
if (!net()) {
std::cout << "SKIP perplexity_live.invalid_key_answers_401_with_the_error_envelope (set MOLO_LIVE_NET=1)\n";
return;
}
auto client = std::make_shared<molo::llm::ApiClient>(
std::make_unique<molo::clients::transports::HttpTransport>(), Platform::config(), "pplx-invalid-molo-probe");
Account acct(client);
try {
acct.models();
FAIL("expected 401");
} catch (const ApiError& e) {
std::cout << " GET /v1/models with an invalid key: " << e.http_status() << " " << e.type() << "\n";
ASSERT_EQ(e.http_status(), 401);
ASSERT_EQ(e.type(), "invalid_api_key");
}
}
TEST(perplexity_live, models_and_usage_are_read_only) {
Platform p = Platform::from_env();
if (!net() || !p.configured()) {
std::cout << "SKIP perplexity_live.models_and_usage_are_read_only (set MOLO_LIVE_NET=1 and PERPLEXITY_API_KEY)\n";
return;
}
Account acct(p.client);
ModelList models = acct.models();
std::cout << " agent models: " << models.models.size() << "\n";
ASSERT_TRUE(!models.models.empty());
}
TEST(perplexity_live, one_smallest_search_and_one_sonar_completion) {
Platform p = Platform::from_env();
if (!net() || !p.configured() || !paid()) {
std::cout << "SKIP perplexity_live.one_smallest_search_and_one_sonar_completion "
"(set MOLO_LIVE_NET=1, MOLO_LIVE_PAID=1 and PERPLEXITY_API_KEY)\n";
return;
}
SearchParams sp = SearchParams::of("perplexity api", 1);
sp.max_tokens_per_page = 64;
SearchResponse sr = Search(p.client).run(sp);
std::cout << " search results: " << sr.results.size() << "\n";
ASSERT_TRUE(!sr.id.empty());
SonarParams params = SonarParams::prompt("Reply with the single word: ok");
params.max_tokens = 8;
params.disable_search = true;
SonarResult r = Sonar(p.client).create(params);
std::cout << " completion finish=" << r.first().finish_reason << " tokens=" << r.usage.total_tokens << "\n";
ASSERT_TRUE(r.usage.present);
}
+194
View File
@@ -0,0 +1,194 @@
// PerplexityChatModel (neutral seam), the call table, error table and rules.
#include <set>
#include "support.h"
#include "vendors/perplexity/calls.h"
#include "vendors/perplexity/chat_model.h"
#include "vendors/perplexity/errors.h"
#include "vendors/perplexity/rules.h"
using namespace molo::perplexity;
using namespace perplexity_test;
using molo::llm::ApiError;
namespace {
const char* kReply =
"{\"id\":\"c1\",\"model\":\"sonar\",\"created\":1,\"choices\":[{\"index\":0,\"finish_reason\":\"length\",\"message\":{\"role\":\"assistant\",\"content\":\"4\"},\"delta\":{\"role\":\"assistant\",\"content\":\"\"}}],"
"\"citations\":[\"https://example.com/a\"],\"usage\":{\"prompt_tokens\":3,\"completion_tokens\":1,\"total_tokens\":4,\"reasoning_tokens\":1,\"cost\":{\"input_tokens_cost\":0,\"output_tokens_cost\":0,\"total_cost\":0}}}";
const char* kStream =
"data: {\"id\":\"s\",\"choices\":[{\"index\":0,\"delta\":{\"role\":\"assistant\",\"content\":\"4\"},\"finish_reason\":null}]}\n\n"
"data: {\"id\":\"s\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"\"},\"finish_reason\":\"stop\"}],\"usage\":{\"prompt_tokens\":3,\"completion_tokens\":1,\"total_tokens\":4,\"cost\":{\"input_tokens_cost\":0,\"output_tokens_cost\":0,\"total_cost\":0}}}\n\n"
"data: [DONE]\n\n";
} // namespace
TEST(perplexity_chat_model, generate_maps_request_and_response) {
Rig rig;
rig.transport->expect_response(Method::kPost, "/v1/sonar", reply(kReply));
PerplexityChatModel model(std::make_shared<Sonar>(rig.client()));
molo::llm::ChatRequest req;
req.system = "Be terse.";
req.messages.push_back(molo::llm::Message::user("2+2?"));
req.max_tokens = 5;
req.temperature = 0.2;
req.reasoning_effort = "low";
req.extra = Json::parse("{\"search_mode\":\"academic\",\"disable_search\":true}");
molo::llm::ChatResponse res = model.generate(req);
ASSERT_EQ(model.vendor(), "perplexity");
ASSERT_EQ(res.text(), "4");
ASSERT_EQ(res.finish_reason, "length");
ASSERT_EQ(res.usage.input_tokens, 3);
ASSERT_EQ(res.usage.reasoning_tokens, 1);
ASSERT_EQ(res.raw.find("citations")->as_array().size(), 1u);
auto s = rig.last();
ASSERT_TRUE(has(s.body, "\"model\":\"sonar\""));
ASSERT_TRUE(has(s.body, "{\"content\":\"Be terse.\",\"role\":\"system\"}"));
ASSERT_TRUE(has(s.body, "\"max_tokens\":5"));
ASSERT_TRUE(has(s.body, "\"search_mode\":\"academic\""));
ASSERT_TRUE(has(s.body, "\"disable_search\":true"));
}
TEST(perplexity_chat_model, response_schema_and_images) {
Rig rig;
rig.transport->expect_response(Method::kPost, "/v1/sonar", reply(kReply));
PerplexityChatModel model(std::make_shared<Sonar>(rig.client()), "sonar-pro");
molo::llm::ChatRequest req;
molo::llm::Message m;
m.role = molo::llm::Role::kUser;
m.parts.push_back(molo::llm::ContentPart::of_text("what is this"));
molo::llm::ImageData img;
img.mime = "image/png";
img.bytes = "abc";
m.parts.push_back(molo::llm::ContentPart::of_image(img));
req.messages.push_back(m);
req.response_schema = Json::parse("{\"type\":\"object\"}");
model.generate(req);
auto s = rig.last();
ASSERT_TRUE(has(s.body, "\"model\":\"sonar-pro\""));
ASSERT_TRUE(has(s.body, "\"image_url\":{\"url\":\"data:image/png;base64,YWJj\"}"));
ASSERT_TRUE(has(s.body, "\"response_format\":{\"json_schema\":"));
}
TEST(perplexity_chat_model, unsupported_features_are_rejected_loudly) {
Rig rig;
PerplexityChatModel model(std::make_shared<Sonar>(rig.client()));
molo::llm::ChatRequest req;
req.messages.push_back(molo::llm::Message::user("hi"));
molo::llm::ToolSpec t;
t.name = "f";
req.tools.push_back(t);
ASSERT_THROW(model.generate(req), ApiError);
req.tools.clear();
req.json_mode = true;
ASSERT_THROW(model.generate(req), ApiError);
req.json_mode = false;
req.extra = Json::parse("{\"temperature_typo\":1}");
ASSERT_THROW(model.generate(req), ApiError);
req.extra = Json();
molo::llm::Message tool;
tool.role = molo::llm::Role::kTool;
tool.parts.push_back(molo::llm::ContentPart::of_result({"c", "r", false}));
req.messages.push_back(tool);
ASSERT_THROW(model.generate(req), ApiError);
ASSERT_EQ(rig.transport->send_count(), 0u);
}
TEST(perplexity_chat_model, stream_emits_text_finish_and_usage) {
Rig rig;
rig.transport->expect_response(Method::kPost, "/v1/sonar", sse(kStream));
PerplexityChatModel model(std::make_shared<Sonar>(rig.client()));
molo::llm::ChatRequest req;
req.messages.push_back(molo::llm::Message::user("2+2?"));
std::string text, finish;
int total = 0;
model.stream(req, [&](const molo::llm::ChatChunk& c) {
text += c.text_delta;
if (!c.finish_reason.empty()) finish = c.finish_reason;
if (c.usage) total = c.usage->total_tokens;
return true;
});
ASSERT_EQ(text, "4");
ASSERT_EQ(finish, "stop");
ASSERT_EQ(total, 4);
}
TEST(perplexity_calls, table_is_consistent) {
std::set<std::string> seen;
for (std::size_t i = 0; i < Calls::count(); ++i) {
const CallSpec& s = Calls::at(i);
ASSERT_TRUE(std::string(s.path).front() == '/');
ASSERT_TRUE(seen.insert(std::string(s.http_method) + " " + s.path).second); // no duplicate rows
ASSERT_EQ(&Calls::spec_of(s.call) == &s, true);
}
ASSERT_EQ(Calls::count(), 39u);
ASSERT_TRUE(Calls::schema_count() > 40);
}
TEST(perplexity_calls, render_validates_every_id) {
ASSERT_EQ(Calls::render(Call::kSonar), "/v1/sonar");
ASSERT_EQ(Calls::render(Call::kAgentGet, "resp_1"), "/v1/agent/resp_1");
ASSERT_EQ(Calls::render(Call::kAgentFileContent, std::vector<std::string>{"r", "f"}), "/v1/agent/r/files/f/content");
ASSERT_EQ(Calls::render(Call::kOrchModel, "perplexity/kimi-k3"), "/orchestrator/v1/models/perplexity/kimi-k3");
ASSERT_THROW(Calls::render(Call::kAgentGet, "../x"), ApiError);
ASSERT_THROW(Calls::render(Call::kAgentGet, ""), ApiError);
ASSERT_THROW(Calls::render(Call::kAgentGet), ApiError); // missing id
ASSERT_THROW(Calls::render(Call::kSonar, "extra"), ApiError); // unexpected id
ASSERT_THROW(Calls::render(Call::kBatchGet, "a/b"), ApiError); // only models may carry a slash
ASSERT_EQ(Calls::method_of(Call::kSkillUpdate) == molo::clients::Method::kPut, true);
ASSERT_EQ(Calls::method_of(Call::kFileDelete) == molo::clients::Method::kDelete, true);
}
TEST(perplexity_errors, table_and_advice) {
ASSERT_TRUE(Errors::kind_of(401) == ErrorKind::kAuth);
ASSERT_TRUE(Errors::kind_of(402) == ErrorKind::kPayment);
ASSERT_TRUE(Errors::kind_of(429) == ErrorKind::kRateLimit);
ASSERT_TRUE(Errors::kind_of(204) == ErrorKind::kNone);
ASSERT_TRUE(Errors::kind_of(418) == ErrorKind::kOther);
ASSERT_TRUE(Errors::retryable(429));
ASSERT_TRUE(Errors::retryable(503));
ASSERT_FALSE(Errors::retryable(400));
ASSERT_FALSE(Errors::retryable(401));
ASSERT_EQ(Errors::wait_seconds(400), 0);
ASSERT_TRUE(Errors::wait_seconds(429) >= 1 && Errors::wait_seconds(429) <= Errors::kMaxWaitSeconds);
ASSERT_TRUE(Errors::is_rate_limit_type("token_rate_limit_exceeded"));
ASSERT_FALSE(Errors::is_rate_limit_type("invalid_api_key"));
ApiError e("perplexity", 402, "x", "no credits");
ASSERT_TRUE(has(Errors::explain(e), "Payment Required"));
ASSERT_TRUE(has(Errors::explain(ApiError("perplexity", 599, "weird", "m")), "weird"));
}
TEST(perplexity_rules, formats) {
Rules::date("01/31/2025", "d");
Rules::date("1/2/2025", "d");
ASSERT_THROW(Rules::date("2025-01-31", "d"), ApiError);
ASSERT_THROW(Rules::date("13/01/2025", "d"), ApiError);
ASSERT_THROW(Rules::date("01/32/2025", "d"), ApiError);
ASSERT_THROW(Rules::date("01/01/25", "d"), ApiError);
Rules::language("en", "l");
ASSERT_THROW(Rules::language("english", "l"), ApiError);
ASSERT_THROW(Rules::language("e1", "l"), ApiError);
Rules::model("perplexity/kimi-k3");
ASSERT_THROW(Rules::model(""), ApiError);
ASSERT_THROW(Rules::model("a b"), ApiError);
ASSERT_THROW(Rules::model(std::string(129, 'a')), ApiError);
ASSERT_THROW(Rules::https_url("http://example.com", "u"), ApiError);
ASSERT_THROW(Rules::https_url("https://user@example.com", "u"), ApiError);
Rules::https_url("https://example.com/mcp", "u");
ASSERT_EQ(Rules::url_encode("a b&c"), "a%20b%26c");
ASSERT_THROW(Rules::filename("a/b"), ApiError);
ASSERT_THROW(Rules::top_p(1.5), ApiError);
Rules::top_p(0.0);
Rules::temperature(2.0);
ASSERT_THROW(Rules::temperature(-0.1), ApiError);
}
TEST(perplexity_platform, key_travels_in_the_header_only) {
Rig rig;
rig.transport->expect_response(Method::kPost, "/v1/sonar", reply(kReply));
Sonar(rig.client()).create(SonarParams::prompt("hi"));
auto s = rig.last();
ASSERT_EQ(s.headers.get_or("Authorization", ""), std::string("Bearer ") + kKey);
ASSERT_EQ(s.target.find(kKey), std::string::npos);
ASSERT_EQ(s.body.find(kKey), std::string::npos);
ASSERT_EQ(std::string(Platform::kKeyEnv), "PERPLEXITY_API_KEY");
ASSERT_EQ(std::string(Platform::config().base_url), "https://api.perplexity.ai");
}
+345
View File
@@ -0,0 +1,345 @@
// Decisions, batches and batch files, skills, models, usage analytics, auth
// tokens and the Orchestrator API.
#include "support.h"
#include "vendors/perplexity/account.h"
#include "vendors/perplexity/batches.h"
#include "vendors/perplexity/decisions.h"
#include "vendors/perplexity/orchestrator.h"
#include "vendors/perplexity/skills.h"
using namespace molo::perplexity;
using namespace perplexity_test;
using molo::llm::ApiError;
namespace {
// FIXTURE: docs, Decisions "ledger" recipe: "This is what it returned on 2026-10-15".
const char* kDecisions =
"{\"model\":\"pplx-decider-latest\",\"answers\":{"
"\"on_policy\":{\"type\":\"noul\",\"noul\":2.2697375997445083e-05},"
"\"matches_records\":{\"type\":\"noul\",\"noul\":2.8507326485291256e-05},"
"\"reversible\":{\"type\":\"noul\",\"noul\":0.015321437622110887}},"
"\"usage\":{\"input_tokens\":1113,\"output_tokens\":3}}";
// SCHEMA: ChoiceAnswer and ScoreAnswer
const char* kDecisionsMixed =
"{\"model\":\"pplx-decider-v1.2\",\"answers\":{"
"\"kind\":{\"type\":\"choice\",\"choice\":\"bug\",\"confidence\":0.8,\"probabilities\":{\"bug\":0.9,\"feature\":0.1}},"
"\"urgency\":{\"type\":\"score\",\"score\":1.4,\"confidence\":0.5,\"legend\":{\"0\":\"low\",\"1\":\"high\"},\"probabilities\":{\"0\":0.6,\"1\":0.4}}},"
"\"usage\":{\"input_tokens\":10,\"output_tokens\":2}}";
// FIXTURE: docs, Batch API "Response (abbreviated)"
const char* kBatch =
"{\"id\":\"batch_01M4RFGZENVEQTVVJ2222M2JD6\",\"object\":\"batch\",\"status\":\"validating\",\"input_file_id\":\"file_01M4RFGV5DQFAZY29N9C2624A6\","
"\"created_at\":1791822953,\"expires_at\":1791995753,\"output_file_id\":null,\"error_file_id\":null,"
"\"request_counts\":{\"completed\":0,\"failed\":0,\"total\":3},\"metadata\":{\"job\":\"nightly-eval\"}}";
// SCHEMA: BatchFile, BatchFileList, BatchFileDeleted
const char* kBatchFile =
"{\"id\":\"file_1\",\"object\":\"file\",\"bytes\":120,\"created_at\":5,\"expires_at\":99,\"filename\":\"in.jsonl\",\"purpose\":\"batch\"}";
// SCHEMA: ManagedSkill, SkillList
const char* kSkill =
"{\"skill_id\":\"skill_abc\",\"name\":\"pdf-notes\",\"description\":\"d\",\"revision\":\"r1\",\"latest_revision\":\"r2\",\"created_at\":\"2026-10-01T00:00:00Z\",\"updated_at\":\"2026-10-02T00:00:00Z\"}";
const std::string kZip = std::string("PK\x03\x04", 4) + "rest-of-the-archive";
// FIXTURE: OpenAPI example for GET /v1/analytics/computer/usage
const char* kUsageV1 =
"{\"categories\":[\"Model\",\"Credit Source\"],\"data\":[{\"start_time\":1746057600,\"end_time\":1746144000,\"count\":350,\"by_categories\":{\"Model\":[{\"category\":\"claude-opus-5-5\",\"count\":210},{\"category\":\"claude-sonnet-5-5\",\"count\":120}],\"Credit Source\":[{\"category\":\"paid\",\"count\":250},{\"category\":\"promo\",\"count\":80}]}}],\"has_more\":false,\"next_page\":null}";
// FIXTURE: OpenAPI example for GET /v2/analytics/computer/usage
const char* kUsageV2 =
"{\"categories\":[\"Model\",\"Credit Source\"],\"data\":[{\"start_time\":1746057600,\"end_time\":1746144000,\"results\":[{\"user_email\":\"alice@example.com\",\"count\":900,\"by_categories\":{\"Model\":[{\"category\":\"claude-opus-5-5\",\"count\":900}],\"Credit Source\":[{\"category\":\"paid\",\"count\":900}]}},{\"user_email\":\"bob@example.com\",\"count\":500,\"by_categories\":{}}]}],\"has_more\":true,\"next_page\":\"eyJwayI6ICJPUkcjLi4uIn0=\"}";
// FIXTURE: OpenAPI example for GET /v1/models (first entries)
const char* kModels =
"{\"object\":\"list\",\"data\":[{\"id\":\"anthropic/claude-opus-5\",\"object\":\"model\",\"created\":0,\"owned_by\":\"anthropic\"},{\"id\":\"openai/gpt-6-astra\",\"object\":\"model\",\"created\":0,\"owned_by\":\"openai\"}]}";
// SCHEMA: gateway Model with pricing
const char* kOrchModels =
"{\"object\":\"list\",\"data\":[{\"id\":\"perplexity/kimi-k3\",\"object\":\"model\",\"created\":1,\"owned_by\":\"perplexity\",\"pricing\":{\"input\":0.6,\"output\":2.5,\"cache_read\":0.15,\"unit\":\"usd_per_1m_tokens\"}}]}";
} // namespace
TEST(perplexity_decisions, documented_fixture_parses_and_request_is_built) {
Rig rig;
rig.transport->expect_response(Method::kPost, "/v1/decisions", reply(kDecisions));
Decisions api(rig.client());
DecisionsParams p;
p.model = "pplx-decider-latest";
p.state = Json("Invoice 77 for account 4471");
p.questions["on_policy"] = DecisionQuestions::noul("Is the payment allowed by the policy?");
p.questions["reversible"] = DecisionQuestions::noul("", "undoable", "permanent");
DecisionsResult r = api.answer(p);
ASSERT_EQ(r.model, "pplx-decider-latest");
ASSERT_EQ(r.answers.size(), 3u);
ASSERT_EQ(r.answers["reversible"].type, "noul");
ASSERT_TRUE(r.answers["reversible"].noul > 0.015 && r.answers["reversible"].noul < 0.016);
ASSERT_EQ(r.input_tokens, 1113L);
auto s = rig.last();
ASSERT_TRUE(has(s.body, "\"questions\":{\"on_policy\":{\"instructions\":\"Is the payment allowed by the policy?\",\"type\":\"noul\"}"));
ASSERT_TRUE(has(s.body, "\"criteria\":{\"false\":\"permanent\",\"true\":\"undoable\"}"));
}
TEST(perplexity_decisions, choice_and_score_answers_and_limits) {
Rig rig;
rig.transport->expect_response(Method::kPost, "/v1/decisions", reply(kDecisionsMixed));
Decisions api(rig.client());
DecisionsParams p;
p.state = Json::parse("{\"title\":\"crash\"}");
p.questions["kind"] = DecisionQuestions::choice({{"bug", "something broke"}, {"feature", ""}});
p.questions["urgency"] = DecisionQuestions::score({"low", "high"}, "How urgent?");
DecisionsResult r = api.answer(p);
ASSERT_EQ(r.answers["kind"].choice, "bug");
ASSERT_EQ(r.answers["kind"].probabilities["feature"], 0.1);
ASSERT_EQ(r.answers["urgency"].legend["1"], "high");
ASSERT_EQ(r.answers["urgency"].score, 1.4);
ASSERT_TRUE(has(rig.last().body, "\"feature\":null"));
DecisionsParams bad;
ASSERT_THROW(api.answer(bad), ApiError);
bad.state = Json("x");
ASSERT_THROW(api.answer(bad), ApiError); // no questions
for (int i = 0; i < 129; ++i) bad.questions["q" + std::to_string(i)] = DecisionQuestions::noul("?");
ASSERT_THROW(api.answer(bad), ApiError);
ASSERT_THROW(DecisionQuestions::noul(""), ApiError);
ASSERT_THROW(DecisionQuestions::score(std::vector<std::string>(11, "l")), ApiError);
ASSERT_THROW(DecisionQuestions::choice({}), ApiError);
ASSERT_EQ(rig.transport->send_count(), 1u);
}
TEST(perplexity_batches, documented_batch_fixture_and_requests) {
Rig rig;
rig.transport->expect_response(Method::kPost, "/v1/files", reply(kBatchFile));
rig.transport->expect_response(Method::kPost, "/v1/batches", reply(kBatch));
BatchFiles files(rig.client());
BatchInput in;
in.jsonl = "{\"custom_id\":\"1\",\"method\":\"POST\",\"url\":\"/v1/responses\",\"body\":{\"model\":\"a/b\",\"input\":\"hi\"}}\n\n{\"custom_id\":\"2\"}\n";
BatchFileInfo f = files.upload(in);
ASSERT_EQ(f.id, "file_1");
ASSERT_EQ(f.purpose, "batch");
auto up = rig.last();
ASSERT_TRUE(has(up.headers.get_or("Content-Type", ""), "multipart/form-data"));
ASSERT_TRUE(has(up.body, "name=\"purpose\""));
ASSERT_TRUE(has(up.body, "filename=\"batch.jsonl\""));
Batches batches(rig.client());
BatchInfo b = batches.create("file_01M4RFGV5DQFAZY29N9C2624A6", {{"job", "nightly-eval"}}, "key-1");
ASSERT_EQ(b.id, "batch_01M4RFGZENVEQTVVJ2222M2JD6");
ASSERT_EQ(b.status, "validating");
ASSERT_FALSE(b.finished());
ASSERT_EQ(b.total, 3L);
ASSERT_EQ(b.metadata["job"], "nightly-eval");
ASSERT_EQ(b.output_file_id, "");
auto s = rig.last();
ASSERT_TRUE(has(s.body, "\"endpoint\":\"/v1/responses\""));
ASSERT_TRUE(has(s.body, "\"completion_window\":\"24h\""));
ASSERT_EQ(s.headers.get_or("Idempotency-Key", ""), "key-1");
}
TEST(perplexity_batches, list_get_cancel_files_and_limits) {
Rig rig;
rig.transport->expect_response(Method::kGet, "/v1/batches",
reply(std::string("{\"object\":\"list\",\"data\":[") + kBatch + "],\"first_id\":\"a\",\"last_id\":\"b\",\"has_more\":true}"));
rig.transport->expect_response(Method::kPost, "/v1/batches/batch_1/cancel",
reply("{\"id\":\"batch_1\",\"object\":\"batch\",\"status\":\"cancelling\",\"input_file_id\":\"f\"}"));
rig.transport->expect_response(Method::kGet, "/v1/files",
reply(std::string("{\"object\":\"list\",\"data\":[") + kBatchFile + "],\"has_more\":false}"));
rig.transport->expect_response(Method::kDelete, "/v1/files/file_1", reply("{\"id\":\"file_1\",\"object\":\"file\",\"deleted\":true}"));
rig.transport->expect_response(Method::kGet, "/v1/files/file_2/content", reply("{\"line\":1}\n", 200, "application/octet-stream"));
Batches batches(rig.client());
BatchList l = batches.list(10, "batch_0");
ASSERT_EQ(l.batches.size(), 1u);
ASSERT_TRUE(l.has_more);
ASSERT_TRUE(has(rig.last().target, "limit=10"));
ASSERT_TRUE(has(rig.last().target, "after=batch_0"));
ASSERT_EQ(batches.cancel("batch_1").status, "cancelling");
BatchFiles files(rig.client());
BatchFileList fl = files.list(5, "", "asc", "batch_output");
ASSERT_EQ(fl.files.size(), 1u);
ASSERT_TRUE(has(rig.last().target, "order=asc"));
ASSERT_TRUE(has(rig.last().target, "purpose=batch_output"));
ASSERT_TRUE(files.remove("file_1").deleted);
ASSERT_EQ(files.content("file_2"), "{\"line\":1}\n");
size_t before = rig.transport->send_count();
ASSERT_THROW(batches.list(101), ApiError);
ASSERT_THROW(batches.get("a/b"), ApiError);
ASSERT_THROW(files.list(0, "", "sideways"), ApiError);
ASSERT_THROW(files.list(0, "", "", "other"), ApiError);
std::map<std::string, std::string> big;
for (int i = 0; i < 17; ++i) big["k" + std::to_string(i)] = "v";
ASSERT_THROW(batches.create("file_1", big), ApiError);
ASSERT_THROW(batches.create("file_1", {}, std::string(201, 'k')), ApiError);
BatchInput bad;
ASSERT_THROW(files.upload(bad), ApiError);
bad.jsonl = "not json\n";
ASSERT_THROW(files.upload(bad), ApiError);
bad.jsonl = "[1]\n";
ASSERT_THROW(files.upload(bad), ApiError);
ASSERT_EQ(rig.transport->send_count(), before);
}
TEST(perplexity_skills, create_get_update_remove_and_revision_guard) {
Rig rig;
rig.transport->expect_response(Method::kPost, "/v1/skills", reply(kSkill, 201));
rig.transport->expect_response(Method::kGet, "/v1/skills/skill_abc", reply(kSkill));
rig.transport->expect_response(Method::kPut, "/v1/skills/skill_abc", reply(kSkill));
rig.transport->expect_response(Method::kDelete, "/v1/skills/skill_abc", reply("", 204));
rig.transport->expect_response(Method::kGet, "/v1/skills",
reply(std::string("{\"skills\":[{\"skill_id\":\"skill_abc\",\"name\":\"n\",\"revision\":\"r\"}],\"next_page_token\":\"nxt\"}")));
rig.transport->expect_response(Method::kGet, "/v1/skills/skill_abc/revisions",
reply("{\"revisions\":[{\"revision\":\"r2\",\"name\":\"n\",\"created_at\":\"t\"}]}"));
rig.transport->expect_response(Method::kGet, "/v1/skills/skill_abc/download",
reply("{\"revision\":\"r2\",\"name\":\"n\",\"download_url\":\"https://files.example/skill.zip\"}"));
Skills skills(rig.client());
SkillBundle bundle;
bundle.data = kZip;
SkillInfo created = skills.create(bundle);
ASSERT_EQ(created.skill_id, "skill_abc");
ASSERT_EQ(created.latest_revision, "r2");
ASSERT_TRUE(has(rig.last().body, "filename=\"skill.zip\""));
ASSERT_EQ(skills.get("skill_abc", "r1").name, "pdf-notes");
ASSERT_TRUE(has(rig.last().target, "revision=r1"));
SkillInfo upd = skills.update("skill_abc", "r2", bundle);
ASSERT_EQ(upd.skill_id, "skill_abc");
ASSERT_EQ(rig.last().method, "PUT");
ASSERT_TRUE(has(rig.last().target, "expected_revision=r2"));
ASSERT_TRUE(has(rig.last().headers.get_or("Content-Type", ""), "multipart/form-data"));
skills.remove("skill_abc", "r2");
ASSERT_EQ(rig.last().method, "DELETE");
ASSERT_TRUE(has(rig.last().target, "expected_revision=r2"));
SkillList l = skills.list(20);
ASSERT_EQ(l.skills.size(), 1u);
ASSERT_EQ(l.next_page_token, "nxt");
ASSERT_EQ(skills.revisions("skill_abc").revisions[0].revision, "r2");
ASSERT_EQ(skills.download("skill_abc").download_url, "https://files.example/skill.zip");
size_t before = rig.transport->send_count();
ASSERT_THROW(skills.remove("skill_abc", ""), ApiError); // revision is required
ASSERT_THROW(skills.update("skill_abc", "bad rev", bundle), ApiError);
ASSERT_THROW(skills.list(201), ApiError);
SkillBundle notzip;
notzip.data = "not a zip";
ASSERT_THROW(skills.create(notzip), ApiError);
ASSERT_THROW(skills.get("../x"), ApiError);
ASSERT_EQ(rig.transport->send_count(), before);
}
TEST(perplexity_account, models_usage_and_auth_tokens) {
Rig rig;
rig.transport->expect_response(Method::kGet, "/v1/models", reply(kModels));
rig.transport->expect_response(Method::kGet, "/v1/analytics/computer/usage", reply(kUsageV1));
rig.transport->expect_response(Method::kGet, "/v2/analytics/computer/usage", reply(kUsageV2));
rig.transport->expect_response(Method::kPost, "/generate_auth_token",
reply("{\"auth_token\":\"pplx-NEW\",\"created_at_epoch_seconds\":1735689600,\"token_name\":\"ci\"}"));
rig.transport->expect_response(Method::kPost, "/revoke_auth_token", reply("{}"));
Account acct(rig.client());
ModelList m = acct.models();
ASSERT_EQ(m.models.size(), 2u);
ASSERT_EQ(m.find("openai/gpt-6-astra")->provider(), "openai");
UsageQuery q;
q.dataset = "credit_usage";
q.start_time = 1746057600;
q.limit = 7;
UsageReport u = acct.usage(q);
ASSERT_EQ(u.categories.size(), 2u);
ASSERT_EQ(u.buckets.size(), 1u);
ASSERT_EQ(u.buckets[0].count, 350L);
ASSERT_FALSE(u.has_more);
ASSERT_TRUE(has(rig.last().target, "dataset=credit_usage"));
ASSERT_TRUE(has(rig.last().target, "start_time=1746057600"));
UsageQuery q2;
q2.dataset = "query_volume";
q2.group_by = "user_email";
q2.start_time = 1;
UsageReport v2 = acct.usage_per_member(q2);
ASSERT_EQ(v2.buckets.size(), 2u);
ASSERT_EQ(v2.buckets[0].user_email, "alice@example.com");
ASSERT_TRUE(v2.has_more);
ASSERT_EQ(v2.next_page, "eyJwayI6ICJPUkcjLi4uIn0=");
AuthToken t = acct.generate_token("ci");
ASSERT_EQ(t.auth_token, "pplx-NEW");
ASSERT_EQ(t.token_name, "ci");
acct.revoke_token("pplx-NEW");
ASSERT_TRUE(has(rig.last().body, "\"auth_token\":\"pplx-NEW\""));
}
TEST(perplexity_account, usage_query_rules) {
Rig rig;
Account acct(rig.client());
UsageQuery q;
ASSERT_THROW(acct.usage(q), ApiError); // no dataset
q.dataset = "query_volume";
q.bucket_width = "1h";
ASSERT_THROW(acct.usage(q), ApiError); // daily-only dataset
q.bucket_width = "1d";
q.user_email = "a@example.com";
ASSERT_THROW(acct.usage(q), ApiError);
q = UsageQuery();
q.dataset = "credit_usage";
q.limit = 32;
ASSERT_THROW(acct.usage(q), ApiError); // 1d: max 31
q.bucket_width = "1h";
q.limit = 168;
q.query_v1(); // 1h: 168 is the maximum
q.end_time = -5;
q.start_time = 10;
ASSERT_THROW(acct.usage(q), ApiError);
UsageQuery v2;
v2.dataset = "skills";
v2.group_by = "user_email";
ASSERT_THROW(acct.usage_per_member(v2), ApiError); // v2 knows two datasets
v2.dataset = "credit_usage";
v2.group_by = "";
ASSERT_THROW(acct.usage_per_member(v2), ApiError); // group_by required
ASSERT_THROW(acct.revoke_token(""), ApiError);
ASSERT_EQ(rig.transport->send_count(), 0u);
}
TEST(perplexity_orchestrator, chat_messages_responses_and_models) {
Rig rig;
rig.transport->expect_response(Method::kPost, "/orchestrator/v1/chat/completions",
reply("{\"id\":\"c\",\"choices\":[{\"index\":0,\"message\":{\"role\":\"assistant\",\"content\":\"hi\"},\"finish_reason\":\"stop\"}]}"));
rig.transport->expect_response(Method::kPost, "/orchestrator/v1/messages",
reply("{\"id\":\"m\",\"type\":\"message\",\"role\":\"assistant\",\"content\":[{\"type\":\"text\",\"text\":\"hey\"}]}"));
rig.transport->expect_response(Method::kPost, "/orchestrator/v1/responses",
reply("{\"id\":\"r\",\"output\":[{\"type\":\"message\",\"content\":[{\"type\":\"output_text\",\"text\":\"yo\"}]}]}"));
rig.transport->expect_response(Method::kGet, "/orchestrator/v1/models", reply(kOrchModels));
rig.transport->expect_response(Method::kGet, "/orchestrator/v1/models/perplexity/kimi-k3",
reply("{\"id\":\"perplexity/kimi-k3\",\"object\":\"model\",\"created\":1,\"owned_by\":\"perplexity\",\"pricing\":{\"input\":0.6,\"output\":2.5,\"unit\":\"usd_per_1m_tokens\"}}"));
Orchestrator o(rig.client());
ASSERT_EQ(Orchestrator::text_of(Call::kOrchChat, o.chat(Orchestrator::chat_request("perplexity/kimi-k3", "hi"))), "hi");
ASSERT_EQ(Orchestrator::text_of(Call::kOrchMessages, o.messages(Orchestrator::messages_request("perplexity/kimi-k3", "hi", 64))), "hey");
ASSERT_EQ(Orchestrator::text_of(Call::kOrchResponses, o.responses(Orchestrator::responses_request("perplexity/kimi-k3", "hi"))), "yo");
ModelList ml = o.models();
ASSERT_EQ(ml.models.size(), 1u);
ASSERT_TRUE(ml.models[0].pricing.present);
ASSERT_EQ(ml.models[0].pricing.output, 2.5);
ASSERT_EQ(o.model("perplexity/kimi-k3").pricing.input, 0.6);
}
TEST(perplexity_orchestrator, request_rules_are_enforced_before_traffic) {
Rig rig;
Orchestrator o(rig.client());
Json b = Orchestrator::chat_request("kimi-k3", "hi"); // no creator prefix
ASSERT_THROW(o.chat(b), ApiError);
b = Orchestrator::chat_request("perplexity/kimi-k3", "hi");
b.set("surprise", Json(1));
ASSERT_THROW(o.chat(b), ApiError);
Json m = Orchestrator::messages_request("perplexity/kimi-k3", "hi", 10);
m.set("mcp_servers", Json::array());
ASSERT_THROW(o.messages(m), ApiError); // rejected by Perplexity
Json nomax = Orchestrator::chat_request("perplexity/kimi-k3", "hi");
ASSERT_THROW(o.messages(nomax), ApiError); // max_tokens required by the Messages schema
Json r = Orchestrator::responses_request("perplexity/kimi-k3", "hi");
r.set("stream", Json(true));
ASSERT_THROW(o.responses(r), ApiError); // use stream()
Json notstream = Orchestrator::responses_request("perplexity/kimi-k3", "hi");
ASSERT_THROW(o.stream(Call::kOrchResponses, notstream, nullptr), ApiError);
ASSERT_THROW(o.model("a/b/c"), ApiError);
ASSERT_THROW(o.model("../x"), ApiError);
ASSERT_THROW(o.chat(Json::array()), ApiError);
ASSERT_EQ(rig.transport->send_count(), 0u);
}
TEST(perplexity_orchestrator, stream_passes_events_through) {
Rig rig;
rig.transport->expect_response(Method::kPost, "/orchestrator/v1/chat/completions",
sse("data: {\"choices\":[{\"index\":0,\"delta\":{\"content\":\"a\"}}]}\n\ndata: {\"choices\":[{\"index\":0,\"delta\":{\"content\":\"b\"}}]}\n\ndata: [DONE]\n\n"));
Orchestrator o(rig.client());
Json b = Orchestrator::chat_request("perplexity/kimi-k3", "hi");
b.set("stream", Json(true));
std::string text;
o.stream(Call::kOrchChat, b, [&](const molo::llm::SseEvent& e) {
text += J::str(*e.data.find("choices")->as_array()[0].find("delta"), "content");
return true;
});
ASSERT_EQ(text, "ab");
}
+196
View File
@@ -0,0 +1,196 @@
// Search API and Embeddings (standard and contextualized).
#include "security/crypto/Base64.h"
#include "support.h"
#include "vendors/perplexity/embeddings.h"
#include "vendors/perplexity/search.h"
using namespace molo::perplexity;
using namespace perplexity_test;
using molo::llm::ApiError;
namespace {
// FIXTURE: docs "Search API Overview" example response (results with title, url, snippet, date, last_updated),
// completed with the schema's required id.
const char* kSearch =
"{\"results\":[{\"title\":\"Example Article Title\",\"url\":\"https://example.com/article\","
"\"snippet\":\"A short excerpt from the article relevant to the query...\",\"date\":\"2025-01-23\",\"last_updated\":\"2025-09-25\"},"
"{\"title\":\"Another Relevant Source\",\"url\":\"https://example.org/source\","
"\"snippet\":\"Another excerpt showing the structured result format.\",\"date\":\"2024-11-15\",\"last_updated\":\"2025-08-12\"}],"
"\"id\":\"search-1\",\"server_time\":\"2026-10-25T10:00:00Z\"}";
std::string b64(const std::string& raw) { return molo::security::crypto::Base64::encode(raw); }
} // namespace
TEST(perplexity_search, request_body_and_parsing) {
Rig rig;
rig.transport->expect_response(Method::kPost, "/search", reply(kSearch));
Search search(rig.client());
SearchParams p = SearchParams::of("quantum computing", 5);
p.country = "US";
p.search_domain_filter = {"arxiv.org"};
p.search_language_filter = {"en"};
p.search_recency_filter = "week";
p.search_after_date_filter = "01/02/2025";
p.max_tokens_per_page = 2048;
SearchResponse r = search.run(p);
ASSERT_EQ(r.id, "search-1");
ASSERT_EQ(r.results.size(), 2u);
ASSERT_EQ(r.results[0].title, "Example Article Title");
ASSERT_EQ(r.results[0].last_updated, "2025-09-25");
ASSERT_EQ(r.results[1].url, "https://example.org/source");
auto s = rig.last();
ASSERT_TRUE(has(s.body, "\"query\":\"quantum computing\""));
ASSERT_TRUE(has(s.body, "\"max_results\":5"));
ASSERT_TRUE(has(s.body, "\"search_domain_filter\":[\"arxiv.org\"]"));
ASSERT_TRUE(has(s.body, "\"search_after_date_filter\":\"01/02/2025\""));
ASSERT_TRUE(has(s.body, "\"max_tokens_per_page\":2048"));
ASSERT_EQ(s.headers.get_or("Authorization", ""), std::string("Bearer ") + kKey);
}
TEST(perplexity_search, multi_query_is_an_array_capped_at_five) {
Rig rig;
rig.transport->expect_response(Method::kPost, "/search", reply(kSearch));
Search search(rig.client());
SearchParams p;
p.query = {"a", "b", "c"};
search.run(p);
ASSERT_TRUE(has(rig.last().body, "\"query\":[\"a\",\"b\",\"c\"]"));
p.query = {"1", "2", "3", "4", "5", "6"};
ASSERT_THROW(search.run(p), ApiError);
}
TEST(perplexity_search, limits_are_enforced_before_any_traffic) {
Rig rig;
Search search(rig.client());
SearchParams p;
ASSERT_THROW(search.run(p), ApiError); // no query
p = SearchParams::of(" ");
ASSERT_THROW(search.run(p), ApiError); // blank
p = SearchParams::of("x", 21);
ASSERT_THROW(search.run(p), ApiError); // >20 needs people
p.search_type = "people";
p.max_results = 50;
p.to_json(); // 50 is fine for people
p.max_results = 51;
ASSERT_THROW(p.to_json(), ApiError);
p = SearchParams::of("x");
p.search_type = "deep";
ASSERT_THROW(search.run(p), ApiError);
p = SearchParams::of("x");
p.search_domain_filter.assign(21, "example.com");
ASSERT_THROW(search.run(p), ApiError);
p = SearchParams::of("x");
p.search_language_filter = {"eng"};
ASSERT_THROW(search.run(p), ApiError);
p = SearchParams::of("x");
p.max_tokens = 0;
ASSERT_THROW(search.run(p), ApiError);
p = SearchParams::of("x");
p.country = "USA";
ASSERT_THROW(search.run(p), ApiError);
ASSERT_EQ(rig.transport->send_count(), 0u);
}
TEST(perplexity_search, rate_limit_error_keeps_its_type) {
Rig rig;
// Shape documented on the Rate Limits page.
rig.transport->expect_response(
Method::kPost, "/search",
reply("{\"error\":{\"message\":\"Request rate limit exceeded, please try again later.\",\"type\":\"request_rate_limit_exceeded\",\"code\":429}}", 429));
try {
Search(rig.client()).run(SearchParams::of("x"));
FAIL("expected");
} catch (const ApiError& e) {
ASSERT_EQ(e.http_status(), 429);
ASSERT_EQ(e.type(), "request_rate_limit_exceeded");
}
}
TEST(perplexity_embeddings, standard_request_and_int8_decoding) {
Rig rig;
// SCHEMA: EmbeddingsResponse; the vector is 4 signed int8 values.
std::string vec = b64(std::string("\x01\xFF\x7F\x80", 4));
rig.transport->expect_response(
Method::kPost, "/v1/embeddings",
reply("{\"object\":\"list\",\"data\":[{\"object\":\"embedding\",\"index\":0,\"embedding\":\"" + vec +
"\"}],\"model\":\"pplx-embed-v1-0.6b\",\"usage\":{\"prompt_tokens\":3,\"total_tokens\":3,\"cost\":{\"total_cost\":0.00001}}}"));
Embeddings api(rig.client());
EmbedParams p;
p.input = {"hello"};
p.dimensions = 128;
EmbedResult r = api.create(p);
ASSERT_EQ(r.vectors.size(), 1u);
ASSERT_TRUE(r.vectors[0].decodable());
std::vector<std::int8_t> v = r.vectors[0].int8();
ASSERT_EQ(v.size(), 4u);
ASSERT_EQ(static_cast<int>(v[0]), 1);
ASSERT_EQ(static_cast<int>(v[1]), -1);
ASSERT_EQ(static_cast<int>(v[2]), 127);
ASSERT_EQ(static_cast<int>(v[3]), -128);
ASSERT_EQ(r.usage.prompt_tokens, 3L);
ASSERT_EQ(r.usage.cost_total, 0.00001);
auto s = rig.last();
ASSERT_TRUE(has(s.body, "\"input\":\"hello\""));
ASSERT_TRUE(has(s.body, "\"dimensions\":128"));
ASSERT_TRUE(has(s.body, "\"model\":\"pplx-embed-v1-0.6b\""));
ASSERT_EQ(cosine(v, v) > 0.999999, true);
ASSERT_EQ(cosine(v, std::vector<std::int8_t>{0, 0, 0, 0}), 0.0);
}
TEST(perplexity_embeddings, contextualized_groups_chunks_per_document) {
Rig rig;
std::string a = b64(std::string("\x01\x02", 2)), b = b64(std::string("\x03\x04", 2));
rig.transport->expect_response(
Method::kPost, "/v1/contextualizedembeddings",
reply("{\"object\":\"list\",\"model\":\"pplx-embed-context-v1-4b\",\"data\":[{\"object\":\"list\",\"index\":0,\"data\":["
"{\"object\":\"embedding\",\"index\":0,\"embedding\":\"" + a + "\"},{\"object\":\"embedding\",\"index\":1,\"embedding\":\"" + b +
"\"}]}],\"usage\":{\"prompt_tokens\":9,\"total_tokens\":9,\"cost\":{}}}"));
Embeddings api(rig.client());
ContextEmbedParams p;
p.model = EmbedModels::kContext4;
p.input = {{"chunk one", "chunk two"}};
p.dimensions = 2560;
p.encoding_format = "base64_int8";
ContextEmbedResult r = api.create_contextualized(p);
ASSERT_EQ(r.documents.size(), 1u);
ASSERT_EQ(r.documents[0].size(), 2u);
ASSERT_EQ(r.documents[0][1].int8()[1], 4);
ASSERT_TRUE(has(rig.last().body, "\"input\":[[\"chunk one\",\"chunk two\"]]"));
ASSERT_TRUE(has(rig.last().body, "\"encoding_format\":\"base64_int8\""));
}
TEST(perplexity_embeddings, limits_and_model_families_are_enforced) {
Rig rig;
Embeddings api(rig.client());
EmbedParams p;
ASSERT_THROW(api.create(p), ApiError); // empty input
p.input.assign(513, "x");
ASSERT_THROW(api.create(p), ApiError);
p.input = {"x"};
p.dimensions = 127;
ASSERT_THROW(api.create(p), ApiError);
p.dimensions = 1025; // above the 0.6b ceiling
ASSERT_THROW(api.create(p), ApiError);
p.model = EmbedModels::kStandard4;
p.dimensions = 2560;
p.to_json(); // allowed for 4b
p.dimensions = 2561;
ASSERT_THROW(p.to_json(), ApiError);
p.dimensions = 0;
p.model = "pplx-embed-context-v1-0.6b"; // context model on the standard call
ASSERT_THROW(api.create(p), ApiError);
p.model = EmbedModels::kStandard06;
p.encoding_format = "float";
ASSERT_THROW(api.create(p), ApiError);
ContextEmbedParams c;
c.input = {{}};
ASSERT_THROW(api.create_contextualized(c), ApiError);
ASSERT_EQ(rig.transport->send_count(), 0u);
}
TEST(perplexity_embeddings, undecodable_vector_is_reported_not_guessed) {
Vector v;
v.base64 = "!!not base64!!";
ASSERT_FALSE(v.decodable());
ASSERT_EQ(v.int8().size(), 0u);
}
+247
View File
@@ -0,0 +1,247 @@
// Sonar chat completions and async chat completions over the real ApiClient
// with a recording transport. Replies are SCHEMA fixtures (shape from the
// OpenAPI document, values invented); assertions are on what WE send and on
// how WE parse.
#include "support.h"
#include "vendors/perplexity/sonar.h"
using namespace molo::perplexity;
using namespace perplexity_test;
using molo::llm::ApiError;
namespace {
// SCHEMA: CompletionResponse with citations, search_results, images, related_questions, usage.cost
const char* kSonarReply =
"{\"id\":\"c1\",\"model\":\"sonar-pro\",\"created\":1760000000,\"object\":\"chat.completion\","
"\"choices\":[{\"index\":0,\"finish_reason\":\"stop\",\"message\":{\"role\":\"assistant\",\"content\":\"Paris is the capital [1][2].\"},"
"\"delta\":{\"role\":\"assistant\",\"content\":\"\"}}],"
"\"citations\":[\"https://example.com/a\",\"https://example.org/b\"],"
"\"search_results\":[{\"title\":\"A\",\"url\":\"https://example.com/a\",\"date\":\"2025-01-02\",\"last_updated\":\"2025-02-03\",\"snippet\":\"s\",\"source\":\"web\"}],"
"\"images\":[{\"image_url\":\"https://img/1.png\",\"origin_url\":\"https://example.com/a\",\"height\":10,\"width\":20,\"title\":\"t\"}],"
"\"related_questions\":[\"What else?\"],"
"\"usage\":{\"prompt_tokens\":10,\"completion_tokens\":7,\"total_tokens\":17,\"search_context_size\":\"low\",\"citation_tokens\":3,"
"\"num_search_queries\":1,\"reasoning_tokens\":2,\"cost\":{\"input_tokens_cost\":0.001,\"output_tokens_cost\":0.002,\"request_cost\":0.005,\"total_cost\":0.008}}}";
// SCHEMA: stream chunks are CompletionResponse documents whose choices carry delta
const char* kStream =
"data: {\"id\":\"s1\",\"model\":\"sonar\",\"created\":1,\"object\":\"chat.completion\",\"choices\":[{\"index\":0,\"delta\":{\"role\":\"assistant\",\"content\":\"Hel\"},\"message\":{\"role\":\"assistant\",\"content\":\"Hel\"},\"finish_reason\":null}]}\n\n"
": keep-alive\n\n"
"data: {\"id\":\"s1\",\"model\":\"sonar\",\"created\":1,\"choices\":[{\"index\":0,\"delta\":{\"content\":\"lo\"},\"message\":{\"role\":\"assistant\",\"content\":\"Hello\"},\"finish_reason\":null}],\"citations\":[\"https://example.com/a\"]}\n\n"
"data: {\"id\":\"s1\",\"model\":\"sonar\",\"created\":1,\"choices\":[{\"index\":0,\"delta\":{\"content\":\"\"},\"message\":{\"role\":\"assistant\",\"content\":\"Hello\"},\"finish_reason\":\"stop\"}],"
"\"usage\":{\"prompt_tokens\":4,\"completion_tokens\":2,\"total_tokens\":6,\"cost\":{\"input_tokens_cost\":0,\"output_tokens_cost\":0,\"total_cost\":0.001}},\"search_results\":[{\"title\":\"A\",\"url\":\"https://example.com/a\"}]}\n\n"
"data: [DONE]\n\n";
// SCHEMA: AsyncApiChatCompletionsResponse
const char* kAsyncCreated =
"{\"id\":\"req_1\",\"model\":\"sonar-deep-research\",\"created_at\":1760000000,\"status\":\"CREATED\"}";
const char* kAsyncRunning =
"{\"id\":\"req_1\",\"model\":\"sonar-deep-research\",\"created_at\":1760000000,\"started_at\":1760000001,\"status\":\"IN_PROGRESS\"}";
std::string async_done() {
return std::string("{\"id\":\"req_1\",\"model\":\"sonar-deep-research\",\"created_at\":1760000000,\"started_at\":1760000001,\"completed_at\":1760000100,"
"\"status\":\"COMPLETED\",\"response\":") + kSonarReply + "}";
}
// SCHEMA: ListAsyncApiChatCompletionsResponse
const char* kAsyncList =
"{\"next_token\":\"tok\",\"requests\":[{\"id\":\"req_1\",\"created_at\":1,\"model\":\"sonar-deep-research\",\"status\":\"COMPLETED\",\"completed_at\":5},"
"{\"id\":\"req_2\",\"created_at\":2,\"model\":\"sonar-deep-research\",\"status\":\"FAILED\",\"failed_at\":6}]}";
} // namespace
TEST(perplexity_sonar, create_sends_bearer_json_and_parses_every_field) {
Rig rig;
rig.transport->expect_response(Method::kPost, "/v1/sonar", reply(kSonarReply));
Sonar sonar(rig.client());
SonarParams p = SonarParams::prompt("Capital of France?", "sonar-pro");
p.add(Messages::system("Be brief."));
p.search_mode = "academic";
p.search_domain_filter = {"nature.com", "-pinterest.com"};
p.search_recency_filter = "month";
p.web_search_options.search_context_size = "high";
p.web_search_options.user_location.country = "FR";
p.return_images = true;
p.return_related_questions = true;
p.reasoning_effort = "low";
SonarResult r = sonar.create(p);
ASSERT_EQ(r.text(), "Paris is the capital [1][2].");
ASSERT_EQ(r.first().finish_reason, "stop");
ASSERT_EQ(r.model, "sonar-pro");
ASSERT_EQ(r.created, 1760000000L);
ASSERT_EQ(r.citations.size(), 2u);
ASSERT_EQ(r.citation_url(2), "https://example.org/b");
ASSERT_EQ(r.citation_url(3), "");
ASSERT_EQ(r.search_results.size(), 1u);
ASSERT_EQ(r.search_results[0].last_updated, "2025-02-03");
ASSERT_EQ(r.images.size(), 1u);
ASSERT_EQ(r.images[0].width, 20L);
ASSERT_EQ(r.related_questions[0], "What else?");
ASSERT_EQ(r.usage.prompt_tokens, 10);
ASSERT_EQ(r.usage.reasoning_tokens, 2);
ASSERT_EQ(r.usage.num_search_queries, 1);
ASSERT_EQ(r.usage.cost.total, 0.008);
ASSERT_EQ(r.usage.cost.request, 0.005);
auto s = rig.last();
ASSERT_EQ(s.method, "POST");
ASSERT_EQ(s.headers.get_or("Authorization", ""), std::string("Bearer ") + kKey);
ASSERT_TRUE(has(s.body, "\"model\":\"sonar-pro\""));
ASSERT_TRUE(has(s.body, "\"search_mode\":\"academic\""));
ASSERT_TRUE(has(s.body, "\"search_domain_filter\":[\"nature.com\",\"-pinterest.com\"]"));
ASSERT_TRUE(has(s.body, "\"web_search_options\":{\"search_context_size\":\"high\",\"user_location\":{\"country\":\"FR\"}}"));
ASSERT_TRUE(has(s.body, "\"reasoning_effort\":\"low\""));
ASSERT_FALSE(has(s.body, "\"stream\""));
ASSERT_EQ(s.target.find(kKey), std::string::npos);
}
TEST(perplexity_sonar, structured_output_and_multimodal_parts_are_in_the_body) {
Rig rig;
rig.transport->expect_response(Method::kPost, "/v1/sonar", reply(kSonarReply));
Sonar sonar(rig.client());
SonarParams p;
p.add(Messages::with_parts("user", {Messages::text_part("describe"), Messages::image_part("https://example.com/x.png"),
Messages::pdf_part("https://example.com/x.pdf"), Messages::video_part("https://example.com/x.mp4", 30)}));
p.response_format = StructuredOutput::json_schema(Json::parse("{\"type\":\"object\",\"properties\":{\"a\":{\"type\":\"string\"}}}"), "answer");
p.stop = {"END"};
sonar.create(p);
auto s = rig.last();
ASSERT_TRUE(has(s.body, "\"image_url\":{\"url\":\"https://example.com/x.png\"}"));
ASSERT_TRUE(has(s.body, "\"pdf_url\":{\"url\":\"https://example.com/x.pdf\"}"));
ASSERT_TRUE(has(s.body, "\"video_url\":{\"frame_interval\":30,\"url\":\"https://example.com/x.mp4\"}"));
ASSERT_TRUE(has(s.body, "\"response_format\":{\"json_schema\":{\"name\":\"answer\""));
ASSERT_TRUE(has(s.body, "\"stop\":\"END\""));
}
TEST(perplexity_sonar, invalid_input_never_reaches_the_network) {
Rig rig;
Sonar sonar(rig.client());
SonarParams empty;
ASSERT_THROW(sonar.create(empty), ApiError);
SonarParams p = SonarParams::prompt("x");
p.temperature = 2.5;
ASSERT_THROW(sonar.create(p), ApiError);
p = SonarParams::prompt("x");
p.search_after_date_filter = "2025-01-01";
ASSERT_THROW(sonar.create(p), ApiError);
p = SonarParams::prompt("x");
p.search_mode = "dark";
ASSERT_THROW(sonar.stream(p, nullptr), ApiError);
p = SonarParams::prompt("x");
p.extra = Json::parse("{\"not_a_field\":1}");
ASSERT_THROW(sonar.create(p), ApiError);
ASSERT_THROW(sonar.get_async("../x"), ApiError);
ASSERT_EQ(rig.transport->send_count(), 0u);
}
TEST(perplexity_sonar, not_configured_has_no_traffic) {
Rig rig("");
Sonar sonar(rig.client());
try {
sonar.create(SonarParams::prompt("hi"));
FAIL("expected");
} catch (const molo::llm::NotConfiguredError& e) {
ASSERT_EQ(e.http_status(), 503);
ASSERT_TRUE(has(e.message(), "PERPLEXITY_API_KEY"));
}
ASSERT_EQ(rig.transport->send_count(), 0u);
ASSERT_FALSE(rig.platform.configured());
}
TEST(perplexity_sonar, stream_folds_chunks_citations_and_usage) {
Rig rig;
rig.transport->expect_response(Method::kPost, "/v1/sonar", sse(kStream));
Sonar sonar(rig.client());
std::string text;
int chunks = 0;
SonarResult r = sonar.stream(SonarParams::prompt("Hi"), [&](const SonarDelta& d) {
text += d.content;
++chunks;
return true;
});
ASSERT_EQ(text, "Hello");
ASSERT_EQ(chunks, 3); // the keep-alive comment produces no chunk
ASSERT_EQ(r.text(), "Hello");
ASSERT_EQ(r.first().finish_reason, "stop");
ASSERT_EQ(r.id, "s1");
ASSERT_EQ(r.citations.size(), 1u);
ASSERT_EQ(r.search_results.size(), 1u);
ASSERT_EQ(r.usage.total_tokens, 6);
ASSERT_EQ(r.usage.cost.total, 0.001);
auto s = rig.last();
ASSERT_TRUE(has(s.body, "\"stream\":true"));
ASSERT_EQ(s.headers.get_or("Accept", ""), "text/event-stream");
}
TEST(perplexity_sonar, stream_stop_early_and_truncation_is_loud) {
Rig rig;
rig.transport->expect_response(Method::kPost, "/v1/sonar", sse(kStream));
Sonar sonar(rig.client());
SonarResult r = sonar.stream(SonarParams::prompt("Hi"), [&](const SonarDelta& d) { return d.content != "Hel"; });
ASSERT_EQ(r.text(), "Hel"); // stopped by the sink: no truncation error
Rig cut;
cut.transport->expect_response(Method::kPost, "/v1/sonar",
sse("data: {\"id\":\"x\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"par\"},\"finish_reason\":null}]}\n\n"));
try {
Sonar(cut.client()).stream(SonarParams::prompt("Hi"), nullptr);
FAIL("expected STREAM_TRUNCATED");
} catch (const ApiError& e) {
ASSERT_EQ(e.type(), "STREAM_TRUNCATED");
}
}
TEST(perplexity_sonar, error_envelope_keeps_vendor_type_and_status) {
Rig rig;
// Shape documented on the Rate Limits page.
rig.transport->expect_response(Method::kPost, "/v1/sonar",
reply("{\"error\":{\"message\":\"Invalid API key provided. Ensure your API key is correct and active.\",\"type\":\"invalid_api_key\",\"code\":401}}", 401));
try {
Sonar(rig.client()).create(SonarParams::prompt("hi"));
FAIL("expected");
} catch (const ApiError& e) {
ASSERT_EQ(e.http_status(), 401);
ASSERT_EQ(e.type(), "invalid_api_key");
ASSERT_EQ(std::string(e.what()).find(kKey), std::string::npos);
}
}
TEST(perplexity_sonar, async_create_get_list_and_wait) {
Rig rig;
rig.transport->expect_response(Method::kPost, "/v1/async/sonar", reply(kAsyncCreated));
Sonar sonar(rig.client());
AsyncJob job = sonar.create_async(SonarParams::prompt("research", "sonar-deep-research"), "idem-1");
ASSERT_EQ(job.id, "req_1");
ASSERT_TRUE(job.state() == AsyncStatus::kCreated);
ASSERT_FALSE(job.finished());
auto s = rig.last();
ASSERT_TRUE(has(s.body, "\"request\":{"));
ASSERT_TRUE(has(s.body, "\"idempotency_key\":\"idem-1\""));
Rig poll;
poll.transport->expect_response(Method::kGet, "/v1/async/sonar/req_1", reply(kAsyncRunning));
poll.transport->expect_response(Method::kGet, "/v1/async/sonar/req_1", reply(async_done()));
Sonar psonar(poll.client());
int slept = 0;
AsyncJob done = psonar.wait_async("req_1", 2, 10, [&](int sec) { slept += sec; });
ASSERT_TRUE(done.state() == AsyncStatus::kCompleted);
ASSERT_TRUE(done.has_response);
ASSERT_EQ(done.response.text(), "Paris is the capital [1][2].");
ASSERT_EQ(slept, 2);
Rig list;
list.transport->expect_response(Method::kGet, "/v1/async/sonar", reply(kAsyncList));
AsyncList l = Sonar(list.client()).list_async();
ASSERT_EQ(l.requests.size(), 2u);
ASSERT_TRUE(l.requests[1].state() == AsyncStatus::kFailed);
ASSERT_EQ(l.next_token, "tok");
}
TEST(perplexity_sonar, wait_async_has_a_floor_and_a_ceiling) {
Rig rig;
Sonar sonar(rig.client());
ASSERT_THROW(sonar.wait_async("req_1", 0, 10), ApiError);
ASSERT_THROW(sonar.wait_async("req_1", 1, 601), ApiError);
rig.transport->expect(MockExpectation{Method::kGet, "/v1/async/sonar/req_1", {}, "", nullptr, reply(kAsyncRunning), nullptr, 100, 0, ""});
try {
sonar.wait_async("req_1", 5, 10, [](int) {});
FAIL("expected WAIT_TIMEOUT");
} catch (const ApiError& e) {
ASSERT_EQ(e.type(), "WAIT_TIMEOUT");
ASSERT_EQ(e.http_status(), 504);
}
}