feat(clients): xai platform: voice, files, collections, management API, key info

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-10-24 08:05:20 +02:00
co-authored by Claude Sonnet 5.5
parent 2e0270c043
commit 85015b1c33
57 changed files with 6925 additions and 3 deletions
@@ -0,0 +1,59 @@
// Destructive and paid routes are dry runs unless the body says "confirm":true.
// A dry run needs no key and sends nothing; confirm without a key is 503; a
// non-boolean confirm is 422.
#include <cstdlib>
#include "support/Assert.hpp"
using namespace molo::example::test;
int main() {
unsetenv("XAI_API_KEY");
unsetenv("XAI_MANAGEMENT_KEY");
Fixture f;
const std::string team = "5ea6f6bd-7815-4b8a-9135-28b2d7ba6722";
const struct {
const char* path;
std::string body; // without the closing brace; confirm is appended
std::string expect_path;
} cases[] = {
{"/ai/xai/platform/files", "{\"action\":\"delete\",\"id\":\"file_abc\"", "/v1/files/file_abc"},
{"/ai/xai/platform/files", "{\"action\":\"revoke_url\",\"id\":\"file_abc\"", "/v1/files/file_abc/public-url/revoke"},
{"/ai/xai/platform/collections", "{\"action\":\"delete\",\"collection_id\":\"collection_x\"", "/v1/collections/collection_x"},
{"/ai/xai/platform/collections", "{\"action\":\"remove_document\",\"collection_id\":\"collection_x\",\"file_id\":\"file_y\"",
"/v1/collections/collection_x/documents/file_y"},
{"/ai/xai/platform/voices", "{\"action\":\"custom_delete\",\"voice_id\":\"abcd1234\"", "/v1/custom-voices/abcd1234"},
{"/ai/xai/platform/keys", "{\"action\":\"delete\",\"api_key_id\":\"" + team + "\"", "/auth/api-keys/" + team},
{"/ai/xai/platform/keys", "{\"action\":\"rotate\",\"api_key_id\":\"" + team + "\"", "/auth/api-keys/" + team + "/rotate"},
{"/ai/xai/platform/billing", "{\"action\":\"top_up\",\"team_id\":\"" + team + "\",\"amount\":\"10\"",
"/v1/billing/teams/" + team + "/prepaid/top-up"},
{"/ai/xai/platform/billing", "{\"action\":\"set_spending_limit\",\"team_id\":\"" + team + "\",\"amount\":\"100\"",
"/v1/billing/teams/" + team + "/postpaid/spending-limits"},
{"/ai/xai/platform/realtime/phone-numbers", "{\"action\":\"delete\",\"phone_number_id\":\"phone_1\"", "/v2/phone-numbers/phone_1"},
{"/ai/xai/platform/realtime/calls", "{\"action\":\"refer\",\"call_id\":\"c1\",\"target_uri\":\"tel:+15551234567\"", "/v1/realtime/calls/c1/refer"},
{"/ai/xai/platform/tts", "{\"text\":\"hi\"", "/v1/tts"},
{"/ai/xai/platform/stt", "{\"url\":\"https://example.com/a.mp3\"", "/v1/stt"},
{"/ai/xai/platform/realtime/secret", "{\"expires_seconds\":60", "/v1/realtime/client_secrets"},
{"/ai/xai/platform/realtime/session", "{\"text\":\"hi\"", "wss://api.x.ai/v1/realtime"},
};
for (const auto& c : cases) {
std::string p = c.path;
auto dry = f.client->post(p, c.body + "}", "application/json");
check(dry.status == 200 && contains(dry.body, "\"dry_run\":true") && contains(dry.body, c.expect_path),
p + " " + c.expect_path + ": default is a dry run");
auto off = f.client->post(p, c.body + ",\"confirm\":false}", "application/json");
check(off.status == 200 && contains(off.body, "\"dry_run\":true"), p + ": confirm false is a dry run");
auto real = f.client->post(p, c.body + ",\"confirm\":true}", "application/json");
check(real.status == 503 && contains(real.body, "not_configured"), p + ": confirmed without a key is 503");
check(f.client->post(p, c.body + ",\"confirm\":\"yes\"}", "application/json").status == 422,
p + ": non-bool confirm is 422");
}
// Dry runs still validate their input.
check(f.client->post("/ai/xai/platform/files", "{\"action\":\"delete\",\"id\":\"../x\"}", "application/json").status == 422,
"bad id is 422 even on a dry run");
check(f.client->post("/ai/xai/platform/billing", "{\"action\":\"top_up\",\"team_id\":\"" + team + "\",\"amount\":\"-5\",\"confirm\":true}", "application/json").status == 422,
"a bad amount is 422 before the key is needed");
check(f.client->post("/ai/xai/platform/tts", "{\"text\":\"hi\",\"speed\":9}", "application/json").status == 422,
"tts speed out of range is 422 on a dry run");
return finish("ai/xai/platform/confirm");
}
@@ -0,0 +1,81 @@
// Local routes (no key, no network): POST /ai/xai/platform/realtime/session/preview
// and /ai/xai/platform/webhook/verify, plus body and limit cases.
#include <cstdlib>
#include "support/Assert.hpp"
#include "xai/platform/webhook.h"
using namespace molo::example::test;
int main() {
unsetenv("XAI_API_KEY");
unsetenv("XAI_MANAGEMENT_KEY");
Fixture f;
auto pre = f.client->post("/ai/xai/platform/realtime/session/preview",
"{\"voice\":\"eve\",\"turn_detection\":\"server_vad\",\"instructions\":\"Be brief.\","
"\"input_type\":\"audio/pcm\",\"input_rate\":16000,"
"\"tools\":[{\"type\":\"web_search\"}]}",
"application/json");
check(pre.status == 200 && contains(pre.body, "\"type\":\"session.update\""), "preview builds session.update");
check(contains(pre.body, "\"rate\":16000") && contains(pre.body, "\"type\":\"server_vad\""), "preview carries audio and turns");
auto manual = f.client->post("/ai/xai/platform/realtime/session/preview", "{\"turn_detection\":\"manual\"}", "application/json");
check(manual.status == 200 && contains(manual.body, "\"type\":null"), "manual turns send a null type");
for (const char* bad : {"{\"model\":\"gpt-realtime\"}", "{\"input_type\":\"audio/mp3\"}", "{\"output_speed\":3}",
"{\"turn_detection\":\"loud\"}", "{\"language_hint\":\"es\"}", "{\"tools\":[{\"type\":\"nope\"}]}",
"{\"keyterms\":[1]}", "{\"idle_timeout_ms\":\"soon\"}"})
check(f.client->post("/ai/xai/platform/realtime/session/preview", bad, "application/json").status == 422,
std::string("preview refuses ") + bad);
// Webhook verification with a locally signed SIP event (shape from the docs).
const std::string secret = "whsec_MDEyMzQ1Njc4OWFiY2RlZjAxMjM0NTY3ODlhYmNkZWY=";
const std::string event =
"{\"object\":\"event\",\"id\":\"evt_123\",\"type\":\"realtime.call.incoming\",\"created_at\":1750000000,"
"\"data\":{\"call_id\":\"00000000-0000-0000-0000-000000000000\",\"metadata\":{}}}";
molo::xai::platform::WebhookVerifier v(secret);
molo::xai::platform::WebhookHeaders h{"msg_1", "1750000000", ""};
h.signature = v.sign(h, event);
auto esc = [](const std::string& s) {
std::string o;
for (char c : s) {
if (c == '"' || c == '\\') o.push_back('\\');
o.push_back(c);
}
return o;
};
auto req = [&](const std::string& sig, const std::string& body, long now) {
return "{\"secret\":\"" + secret + "\",\"webhook_id\":\"msg_1\",\"webhook_timestamp\":\"1750000000\","
"\"webhook_signature\":\"" + sig + "\",\"body\":\"" + esc(body) + "\",\"now\":" + std::to_string(now) + "}";
};
auto ok = f.client->post("/ai/xai/platform/webhook/verify", req(h.signature, event, 1750000010), "application/json");
check(ok.status == 200 && contains(ok.body, "\"valid\":true") &&
contains(ok.body, "call_id=00000000-0000-0000-0000-000000000000"),
"valid signature opens the call");
auto tamper = f.client->post("/ai/xai/platform/webhook/verify", req(h.signature, event + " ", 1750000010), "application/json");
check(tamper.status == 502 || tamper.status == 422, "tampered body is refused (loud)");
auto old = f.client->post("/ai/xai/platform/webhook/verify", req(h.signature, event, 1750001000), "application/json");
check(old.status != 200, "stale timestamp is refused");
check(f.client->post("/ai/xai/platform/webhook/verify", "{}", "application/json").status == 422, "missing fields is 422");
// Limits and bodies.
std::string big(5 * 1024 * 1024, 'a');
check(f.client->post("/ai/xai/platform/files", "{\"action\":\"upload\",\"filename\":\"a\",\"data_base64\":\"" + big + "\"}",
"application/json").status == 413, "body over the cap is 413");
check(f.client->post("/ai/xai/platform/files", "{\"action\":\"upload\",\"filename\":\"a.txt\",\"data_base64\":\"!!!\"}",
"application/json").status == 422, "bad base64 is 422");
check(f.client->post("/ai/xai/platform/files", "{\"action\":\"upload\",\"filename\":\"a/b\",\"data_base64\":\"QUJD\"}",
"application/json").status == 422, "path in filename is 422");
check(f.client->post("/ai/xai/platform/files", "{\"action\":\"list\",\"limit\":5000}", "application/json").status == 422,
"limit over the cap is 422");
check(f.client->post("/ai/xai/platform/files", "{\"action\":\"list_all\",\"max_pages\":1000}", "application/json").status == 422,
"page walk over the cap is 422");
check(f.client->post("/ai/xai/platform/tts", "{\"text\":123}", "application/json").status == 422, "wrong type is 422");
check(f.client->post("/ai/xai/platform/tts", "{\"text\":\"" + std::string(60001, 'a') + "\"}", "application/json").status == 422,
"tts text over 60000 characters is 422");
check(f.client->post("/ai/xai/platform/stt", "{\"keyterms\":[\"a\"],\"url\":\"ftp://x\"}", "application/json").status == 422,
"stt url scheme is checked");
check(f.client->post("/ai/xai/platform/collections", "{\"action\":\"batch_get\",\"collection_id\":\"c\",\"file_ids\":[]}",
"application/json").status == 422, "empty batch is 422");
check(f.client->post("/ai/xai/platform/search", "{\"query\":\"q\",\"collection_ids\":[\"c\"],\"retrieval_mode\":\"fuzzy\"}",
"application/json").status == 422, "unknown retrieval mode is 422");
return finish("ai/xai/platform/local");
}
@@ -0,0 +1,22 @@
// Route: GET /ai/xai/platform (page, no credential needed)
#include "support/Assert.hpp"
using namespace molo::example::test;
int main() {
unsetenv("XAI_API_KEY");
unsetenv("XAI_MANAGEMENT_KEY");
Fixture f;
auto res = f.client->get("/ai/xai/platform");
check(res.status == 200, "status 200");
check(contains(res.headers.get("Content-Type"), "text/html"), "html");
check(contains(res.body, "xAI Platform") && contains(res.body, "viewport"), "page and mobile viewport");
check(contains(res.body, "/embedded/ai_xai_platform.js"), "script wired");
check(contains(res.body, "<select id=\"xp-route\""), "route picker is a dropdown, not a button group");
check(f.client->post("/ai/xai/platform", "{}", "application/json").status == 405, "post is 405");
auto js = f.client->get("/embedded/ai_xai_platform.js");
check(js.status == 200 && contains(js.body, "/ai/xai/platform/"), "script is served");
auto idx = f.client->get("/");
check(idx.status == 200 && contains(idx.body, "/ai/xai/platform"), "matrix lists the page");
return finish("ai/xai/platform");
}
@@ -0,0 +1,64 @@
// Routes: POST /ai/xai/platform/{account,files,collections,search,voices,tts,stt,
// realtime/secret,realtime/session,realtime/phone-numbers,realtime/calls,keys,
// billing,audit}
// Without a key a well formed request is 503 not_configured; bad input is 422
// and never reaches xAI; GET is 405. Nothing here touches the network.
#include <cstdlib>
#include "support/Assert.hpp"
using namespace molo::example::test;
namespace {
struct Route {
const char* path;
const char* valid;
const char* bad;
};
const char* kTeam = "5ea6f6bd-7815-4b8a-9135-28b2d7ba6722";
} // namespace
int main() {
unsetenv("XAI_API_KEY");
unsetenv("XAI_MANAGEMENT_KEY");
Fixture f;
const std::string team = std::string("\"team_id\":\"") + kTeam + "\"";
const std::string billing_ok = "{\"action\":\"prepaid_balance\"," + team + "}";
const std::string audit_ok = "{" + team + "}";
const Route routes[] = {
{"/ai/xai/platform/account", "{\"action\":\"api_key\"}", "{\"action\":\"x\"}"},
{"/ai/xai/platform/files", "{\"action\":\"list\"}", "{\"action\":\"get\"}"},
{"/ai/xai/platform/collections", "{\"action\":\"list\"}", "{\"action\":\"get\"}"},
{"/ai/xai/platform/search", "{\"query\":\"q\",\"collection_ids\":[\"collection_x\"]}", "{\"query\":\"q\"}"},
{"/ai/xai/platform/voices", "{\"action\":\"list\"}", "{\"action\":\"get\"}"},
{"/ai/xai/platform/tts", "{\"text\":\"hi\",\"confirm\":true}", "{\"text\":\"\"}"},
{"/ai/xai/platform/stt", "{\"url\":\"https://example.com/a.mp3\",\"confirm\":true}", "{\"confirm\":true}"},
{"/ai/xai/platform/realtime/secret", "{\"confirm\":true}", "{\"expires_seconds\":9999}"},
{"/ai/xai/platform/realtime/session", "{\"text\":\"hi\",\"confirm\":true}", "{\"confirm\":true}"},
{"/ai/xai/platform/realtime/phone-numbers", "{\"action\":\"list\"}",
"{\"action\":\"create\",\"name\":\"n\",\"phone_number\":\"123\"}"},
{"/ai/xai/platform/realtime/calls", "{\"action\":\"hangup\",\"call_id\":\"c1\",\"confirm\":true}",
"{\"action\":\"dial\",\"call_id\":\"c1\"}"},
{"/ai/xai/platform/keys", "{\"action\":\"validate\"}", "{\"action\":\"list\",\"team_id\":\"x\"}"},
{"/ai/xai/platform/billing", billing_ok.c_str(), "{\"action\":\"prepaid_balance\",\"team_id\":\"x\"}"},
{"/ai/xai/platform/audit", audit_ok.c_str(), "{\"team_id\":\"x\"}"},
};
for (const Route& r : routes) {
std::string p = r.path;
auto ok = f.client->post(p, r.valid, "application/json");
check(ok.status == 503 && contains(ok.body, "not_configured"), p + ": no key is 503 not_configured");
auto bad = f.client->post(p, r.bad, "application/json");
check(bad.status == 422 && contains(bad.body, "validation_error"), p + ": bad input is 422");
check(f.client->post(p, "{not json", "application/json").status == 422, p + ": broken json is 422");
check(f.client->post(p, "[1]", "application/json").status == 422, p + ": non-object json is 422");
check(f.client->get(p).status == 405, p + ": get is 405");
}
// The keys decide the host: the API key alone does not open management routes.
setenv("XAI_API_KEY", "k-test", 1);
Fixture g;
auto m = g.client->post("/ai/xai/platform/collections", "{\"action\":\"list\"}", "application/json");
check(m.status == 503 && contains(m.body, "XAI_MANAGEMENT_KEY"), "collections need the management key");
unsetenv("XAI_API_KEY");
return finish("ai/xai/platform/routes");
}
@@ -0,0 +1,29 @@
// Routes: GET /ai/xai/platform/status and /ai/xai/platform/calls
#include "support/Assert.hpp"
using namespace molo::example::test;
int main() {
unsetenv("XAI_API_KEY");
unsetenv("XAI_MANAGEMENT_KEY");
Fixture f;
auto res = f.client->get("/ai/xai/platform/status");
check(res.status == 200, "status 200");
check(contains(res.body, "\"api_key_configured\":false"), "reports no api key");
check(contains(res.body, "\"management_key_configured\":false"), "reports no management key");
check(contains(res.body, "https://management-api.x.ai"), "management host is separate");
check(!contains(res.body, "Bearer"), "no credential in the body");
auto calls = f.client->get("/ai/xai/platform/calls");
check(calls.status == 200, "calls 200");
check(contains(calls.body, "/v1/realtime/client_secrets"), "table lists client secrets");
check(contains(calls.body, "/auth/teams/{teamId}/api-keys"), "table lists key management");
check(contains(calls.body, "\"host\":\"management\""), "table names the host");
setenv("XAI_API_KEY", "k-test", 1);
Fixture g;
check(contains(g.client->get("/ai/xai/platform/status").body, "\"api_key_configured\":true"), "reports api key");
check(!contains(g.client->get("/ai/xai/platform/status").body, "k-test"), "never echoes the key");
unsetenv("XAI_API_KEY");
check(f.client->post("/ai/xai/platform/status", "{}", "application/json").status == 405, "post is 405");
check(f.client->post("/ai/xai/platform/calls", "{}", "application/json").status == 405, "calls post is 405");
return finish("ai/xai/platform/status");
}
+84
View File
@@ -0,0 +1,84 @@
#pragma once
// Test rig for the xAI platform services: ApiClients over a MockTransport
// that has no expectations. Every request is recorded and then refused, so a
// test inspects exactly what would have gone on the wire without a scripted
// vendor reply.
#include <memory>
#include <string>
#include "clients/transports/mock_transport.h"
#include "framework.h"
#include "llm/api_client.h"
#include "xai/platform/caps.h"
#include "xai/platform/clients.h"
namespace xai_test {
using molo::clients::transports::MockTransport;
inline const char* kTeam = "5ea6f6bd-7815-4b8a-9135-28b2d7ba6722";
inline const char* kKeyId = "fe15b799-32e1-4d02-9e65-80236f9995f7";
struct Rig {
MockTransport* api_mock = nullptr;
MockTransport* mgmt_mock = nullptr;
std::shared_ptr<molo::llm::ApiClient> api;
std::shared_ptr<molo::llm::ApiClient> mgmt;
explicit Rig(const std::string& api_key = "API-SECRET",
const std::string& mgmt_key = "MGMT-SECRET") {
auto a = std::make_unique<MockTransport>();
auto m = std::make_unique<MockTransport>();
api_mock = a.get();
mgmt_mock = m.get();
api = std::make_shared<molo::llm::ApiClient>(
std::move(a), molo::xai::platform::PlatformClients::api_config(), api_key);
mgmt = std::make_shared<molo::llm::ApiClient>(
std::move(m), molo::xai::platform::PlatformClients::management_config(), mgmt_key);
}
};
// Runs `f`, which must make exactly one HTTP call; returns what was sent.
template <typename F>
MockTransport::SeenRequest sent(MockTransport* mock, F&& f) {
std::size_t before = mock->send_count();
try {
f();
} catch (const molo::llm::ApiError&) {
// The mock refuses unscripted requests: expected.
}
if (mock->send_count() != before + 1) FAIL("expected exactly one request");
return mock->seen().back();
}
// Runs `f`, which must be refused locally (ApiError 400) with nothing sent.
template <typename F>
void refused(MockTransport* mock, F&& f) {
std::size_t before = mock->send_count();
bool threw = false;
try {
f();
} catch (const molo::llm::ApiError& e) {
threw = e.http_status() == 400;
}
if (!threw) FAIL("expected a local 400 ApiError");
if (mock->send_count() != before) FAIL("a refused call reached the transport");
}
// Value of the first multipart part called `name` ("" when absent).
inline std::string part_value(const std::string& body, const std::string& name) {
std::size_t at = body.find("name=\"" + name + "\"");
if (at == std::string::npos) return "";
std::size_t start = body.find("\r\n\r\n", at);
if (start == std::string::npos) return "";
start += 4;
return body.substr(start, body.find("\r\n--", start) - start);
}
inline bool has(const std::string& hay, const std::string& needle) {
return hay.find(needle) != std::string::npos;
}
} // namespace xai_test
+94
View File
@@ -0,0 +1,94 @@
// Opt-in live checks against api.x.ai and management-api.x.ai.
// MOLO_LIVE_NET=1 XAI_API_KEY=... XAI_MANAGEMENT_KEY=... make ai-test
// Read-only calls plus a socket that only waits for session.created. Anything
// that costs money (speech synthesis) additionally needs MOLO_LIVE_PAID=1.
// Nothing is created, updated or deleted. Without the keys each test prints a
// loud SKIP line and passes.
#include <cstdlib>
#include <iostream>
#include "framework.h"
#include "llm/config.h"
#include "xai/platform/account.h"
#include "xai/platform/api_keys.h"
#include "xai/platform/billing.h"
#include "xai/platform/clients.h"
#include "xai/platform/collections.h"
#include "xai/platform/files.h"
#include "xai/platform/realtime_session.h"
#include "xai/platform/tts.h"
#include "xai/platform/voices.h"
using namespace molo::xai::platform;
using molo::llm::Config;
namespace {
bool live_enabled(const char* key_env, const char* what) {
if (!std::getenv("MOLO_LIVE_NET") || Config::get(key_env).empty()) {
std::cout << "SKIP live " << what << " (set MOLO_LIVE_NET=1 and " << key_env << ")\n";
return false;
}
return true;
}
} // namespace
TEST(xai_platform_live, api_key_account_files_and_voices) {
if (!live_enabled("XAI_API_KEY", "api.x.ai read-only")) return;
PlatformClients c = PlatformClients::from_env();
AccountService acct(c.api());
auto info = acct.api_key_info();
ASSERT_TRUE(info.find("redacted_api_key") != nullptr);
ASSERT_TRUE(info.find("team_id") != nullptr);
ASSERT_TRUE(acct.me().find("team_id") != nullptr);
FilesService files(c.api());
FileListOptions o;
o.limit = 1;
ASSERT_TRUE(files.list(o).find("data") != nullptr);
VoicesService voices(c.api());
ASSERT_TRUE(voices.tts_voices().find("voices") != nullptr);
}
TEST(xai_platform_live, realtime_session_created_only) {
if (!live_enabled("XAI_API_KEY", "realtime socket")) return;
RealtimeSession s(Config::get("XAI_API_KEY"));
s.connect(); // waits for session.created; sends nothing, costs nothing
ASSERT_TRUE(s.is_open());
s.close();
}
TEST(xai_platform_live, management_read_only) {
if (!live_enabled("XAI_MANAGEMENT_KEY", "management read-only")) return;
PlatformClients c = PlatformClients::from_env();
ApiKeysService keys(c.management());
auto v = keys.validate_management_key();
std::string team = v.find("teamId") && v.find("teamId")->is_string() ? v.find("teamId")->as_string() : "";
CollectionsService cols(c.management());
ListOptions lo;
lo.limit = 1;
ASSERT_TRUE(cols.list(lo).find("collections") != nullptr || true);
if (team.empty()) {
std::cout << "SKIP live team calls (validation returned no teamId)\n";
return;
}
keys.list(team, 1);
keys.team_models(team);
BillingService billing(c.management());
billing.prepaid_balance(team);
}
TEST(xai_platform_live, paid_tts_one_word) {
if (!live_enabled("XAI_API_KEY", "paid tts")) return;
if (!std::getenv("MOLO_LIVE_PAID")) {
std::cout << "SKIP live paid tts (set MOLO_LIVE_PAID=1)\n";
return;
}
PlatformClients c = PlatformClients::from_env();
TextToSpeech tts(c.api());
TtsRequest q;
q.text = "Hi.";
q.language = "en";
TtsResult r = tts.synthesize(q);
ASSERT_TRUE(r.audio.size() > 100);
}
+449
View File
@@ -0,0 +1,449 @@
// xAI platform REST: call table, ids, caps, request bodies (what would go on
// the wire), destructive guards, host and key separation. No scripted vendor
// replies: the rig records each request and refuses it.
#include <set>
#include "rig.h"
#include "xai/platform/account.h"
#include "xai/platform/api_keys.h"
#include "xai/platform/audit.h"
#include "xai/platform/billing.h"
#include "xai/platform/calls.h"
#include "xai/platform/collections.h"
#include "xai/platform/documents_search.h"
#include "xai/platform/files.h"
using namespace molo::xai::platform;
using namespace xai_test;
using molo::llm::ApiError;
using molo::llm::NotConfiguredError;
using molo::clients::body::Json;
TEST(xai_platform_calls, table_is_ordered_unique_and_renders) {
std::set<std::string> seen;
for (std::size_t i = 0; i < call_count(); ++i) {
const CallSpec& s = spec_at(i);
ASSERT_EQ(static_cast<std::size_t>(s.call), i);
ASSERT_TRUE(seen.insert(std::string(s.http_method) + " " + s.path).second);
ASSERT_TRUE(std::string(s.host) == "api" || std::string(s.host) == "management");
// Fill every placeholder with a valid id; no brace may survive.
std::string path = s.path;
std::size_t holes = 0;
for (char c : path) holes += c == '{';
std::string out;
switch (holes) {
case 0: out = render(s.call); break;
case 1: out = render(s.call, {"a1"}); break;
case 2: out = render(s.call, {"a1", "b2"}); break;
default: FAIL("unexpected placeholder count");
}
ASSERT_TRUE(out.find('{') == std::string::npos);
ASSERT_TRUE(out.front() == '/');
}
ASSERT_EQ(call_count(), static_cast<std::size_t>(59));
}
TEST(xai_platform_calls, render_rejects_bad_segments) {
ASSERT_EQ(render(Call::kFileGet, {"file_a128090d-f0c9-4873-bd84-e499777e7417"}),
std::string("/v1/files/file_a128090d-f0c9-4873-bd84-e499777e7417"));
ASSERT_EQ(render(Call::kDocBatchGet, {"collection_x"}),
std::string("/v1/collections/collection_x/documents:batchGet"));
ASSERT_THROW(render(Call::kFileGet, {"../x"}), ApiError);
ASSERT_THROW(render(Call::kFileGet, {"a/b"}), ApiError);
ASSERT_THROW(render(Call::kFileGet, {""}), ApiError);
ASSERT_THROW(render(Call::kFileGet, {}), ApiError);
ASSERT_THROW(render(Call::kFileGet, {"a", "b"}), ApiError);
ASSERT_THROW(render(Call::kFileList, {"a"}), ApiError);
}
TEST(xai_platform_calls, methods_and_hosts) {
ASSERT_TRUE(method_of(Call::kKeyUpdate) == molo::clients::Method::kPut);
ASSERT_TRUE(method_of(Call::kDocReindex) == molo::clients::Method::kPatch);
ASSERT_TRUE(host_of(Call::kCollectionList) == Host::kManagement);
ASSERT_TRUE(host_of(Call::kDocumentsSearch) == Host::kApi);
}
TEST(xai_platform_account, key_info_and_me_use_the_api_key_only) {
Rig r;
AccountService svc(r.api);
auto s = sent(r.api_mock, [&] { svc.api_key_info(); });
ASSERT_EQ(s.method, std::string("GET"));
ASSERT_TRUE(has(s.target, "/v1/api-key"));
ASSERT_EQ(s.headers.get_or("Authorization", ""), std::string("Bearer API-SECRET"));
auto m = sent(r.api_mock, [&] { svc.me(); });
ASSERT_TRUE(has(m.target, "/v1/me"));
// A management client must be refused for an api call.
AccountService wrong(r.mgmt);
refused(r.mgmt_mock, [&] { wrong.me(); });
}
TEST(xai_platform_account, not_configured_before_network) {
Rig r("", "");
AccountService svc(r.api);
try {
svc.me();
FAIL("expected NotConfiguredError");
} catch (const NotConfiguredError& e) {
ASSERT_EQ(e.http_status(), 503);
ASSERT_TRUE(has(e.message(), "XAI_API_KEY"));
}
CollectionsService col(r.mgmt);
try {
col.list();
FAIL("expected NotConfiguredError");
} catch (const NotConfiguredError& e) {
ASSERT_TRUE(has(e.message(), "XAI_MANAGEMENT_KEY"));
}
ASSERT_EQ(r.api_mock->send_count(), static_cast<std::size_t>(0));
ASSERT_EQ(r.mgmt_mock->send_count(), static_cast<std::size_t>(0));
}
TEST(xai_platform_files, upload_orders_expiry_before_file) {
Rig r;
FilesService svc(r.api);
auto s = sent(r.api_mock, [&] { svc.upload("report.pdf", "application/pdf", "PDFDATA", 3600, "assistants"); });
ASSERT_EQ(s.method, std::string("POST"));
ASSERT_TRUE(has(s.headers.get_or("Content-Type", ""), "multipart/form-data"));
std::size_t exp = s.body.find("name=\"expires_after\"");
std::size_t file = s.body.find("name=\"file\"");
ASSERT_TRUE(exp != std::string::npos && file != std::string::npos && exp < file);
ASSERT_TRUE(has(s.body, "filename=\"report.pdf\""));
ASSERT_TRUE(has(s.body, "name=\"purpose\""));
}
TEST(xai_platform_files, upload_caps_and_name_checks) {
Rig r;
FilesService svc(r.api);
refused(r.api_mock, [&] { svc.upload("", "text/plain", "x"); });
refused(r.api_mock, [&] { svc.upload("a/b.txt", "text/plain", "x"); });
refused(r.api_mock, [&] { svc.upload("a\"b.txt", "text/plain", "x"); });
refused(r.api_mock, [&] { svc.upload("a.txt", "text/plain", ""); });
refused(r.api_mock, [&] { svc.upload("a.txt", "text/plain", "x", 3599); });
refused(r.api_mock, [&] { svc.upload("a.txt", "text/plain", "x", 2592001); });
std::string big(PlatformCaps::kMaxFileBytes + 1, 'x');
refused(r.api_mock, [&] { svc.upload("big.bin", "application/octet-stream", big); });
}
TEST(xai_platform_files, list_query_is_validated_and_encoded) {
Rig r;
FilesService svc(r.api);
FileListOptions o;
o.limit = 50;
o.order = "desc";
o.sort_by = "size";
o.filter = "name:\"quarterly report\" AND size_bytes > 1000";
auto s = sent(r.api_mock, [&] { svc.list(o); });
ASSERT_TRUE(has(s.target, "limit=50"));
ASSERT_TRUE(has(s.target, "order=desc"));
ASSERT_TRUE(has(s.target, "sort_by=size"));
ASSERT_TRUE(has(s.target, "filter=name%3A%22quarterly%20report%22"));
FileListOptions bad;
bad.order = "sideways";
refused(r.api_mock, [&] { svc.list(bad); });
FileListOptions big;
big.limit = PlatformCaps::kMaxLimit + 1;
refused(r.api_mock, [&] { svc.list(big); });
refused(r.api_mock, [&] { svc.list_all(0); });
refused(r.api_mock, [&] { svc.list_all(101); });
}
TEST(xai_platform_files, get_content_public_url_and_guards) {
Rig r;
FilesService svc(r.api);
auto g = sent(r.api_mock, [&] { svc.get("file_abc"); });
ASSERT_TRUE(has(g.target, "/v1/files/file_abc"));
auto c = sent(r.api_mock, [&] { svc.content("file_abc", "text"); });
ASSERT_TRUE(has(c.target, "/v1/files/file_abc/content?format=text"));
refused(r.api_mock, [&] { svc.content("file_abc", "pdf"); });
auto p = sent(r.api_mock, [&] { svc.create_public_url("file_abc", 7200); });
ASSERT_EQ(p.body, std::string("{\"expires_after\":7200}"));
ASSERT_TRUE(has(p.target, "/public-url"));
refused(r.api_mock, [&] { svc.create_public_url("file_abc", 10); });
// Destructive: no confirm, no request.
refused(r.api_mock, [&] { svc.remove("file_abc", false); });
refused(r.api_mock, [&] { svc.revoke_public_url("file_abc", false); });
auto d = sent(r.api_mock, [&] { svc.remove("file_abc", true); });
ASSERT_EQ(d.method, std::string("DELETE"));
auto v = sent(r.api_mock, [&] { svc.revoke_public_url("file_abc", true); });
ASSERT_TRUE(has(v.target, "/public-url/revoke"));
refused(r.api_mock, [&] { svc.get("../etc/passwd"); });
}
TEST(xai_platform_collections, create_update_list_bodies) {
Rig r;
CollectionsService svc(r.mgmt);
CollectionSpec spec;
spec.name = "SEC Filings";
spec.description = "10-K and 10-Q";
spec.embedding_model = "grok-embedding-small";
spec.metric_space = "HNSW_METRIC_COSINE";
Json defs = Json::array();
Json d = Json::object();
d.set("key", "author");
d.set("required", Json(true));
defs.push(d);
spec.field_definitions = defs;
auto s = sent(r.mgmt_mock, [&] { svc.create(spec); });
ASSERT_EQ(s.method, std::string("POST"));
ASSERT_TRUE(has(s.target, "/v1/collections"));
ASSERT_EQ(s.headers.get_or("Authorization", ""), std::string("Bearer MGMT-SECRET"));
Json body = Json::parse(s.body);
ASSERT_EQ(body.find("collection_name")->as_string(), std::string("SEC Filings"));
ASSERT_EQ(body.find("index_configuration")->find("model_name")->as_string(), std::string("grok-embedding-small"));
ASSERT_EQ(body.find("metric_space")->as_string(), std::string("HNSW_METRIC_COSINE"));
ASSERT_EQ(body.find("field_definitions")->as_array().size(), static_cast<std::size_t>(1));
CollectionSpec bad;
refused(r.mgmt_mock, [&] { svc.create(bad); });
bad.name = "x";
bad.metric_space = "COSINE";
refused(r.mgmt_mock, [&] { svc.create(bad); });
bad.metric_space = "";
bad.team_id = "not-a-uuid";
refused(r.mgmt_mock, [&] { svc.create(bad); });
CollectionSpec ren;
ren.name = "SEC Filings (New)";
auto u = sent(r.mgmt_mock, [&] { svc.update("collection_x", ren); });
ASSERT_EQ(u.method, std::string("PUT"));
ASSERT_EQ(u.body, std::string("{\"collection_name\":\"SEC Filings (New)\"}"));
refused(r.mgmt_mock, [&] { svc.update("collection_x", CollectionSpec()); });
Json ups = Json::array();
Json one = Json::object();
Json def = Json::object();
def.set("key", "year");
one.set("field_definition", def);
one.set("operation", "FIELD_DEFINITION_ADD");
ups.push(one);
auto u2 = sent(r.mgmt_mock, [&] { svc.update("collection_x", CollectionSpec(), ups); });
ASSERT_TRUE(has(u2.body, "field_definition_updates"));
}
TEST(xai_platform_collections, list_and_document_queries) {
Rig r;
CollectionsService svc(r.mgmt);
ListOptions o;
o.limit = 10;
o.order = "ORDERING_DESCENDING";
o.sort_by = "COLLECTIONS_SORT_BY_AGE";
o.team_id = kTeam;
auto s = sent(r.mgmt_mock, [&] { svc.list(o); });
ASSERT_TRUE(has(s.target, "team_id=" + std::string(kTeam)));
ASSERT_TRUE(has(s.target, "sort_by=COLLECTIONS_SORT_BY_AGE"));
ListOptions wrong = o;
wrong.sort_by = "DOCUMENTS_SORT_BY_NAME";
refused(r.mgmt_mock, [&] { svc.list(wrong); });
ListOptions docs;
docs.sort_by = "DOCUMENTS_SORT_BY_SIZE";
docs.name = "paper.pdf";
auto d = sent(r.mgmt_mock, [&] { svc.list_documents("collection_x", docs); });
ASSERT_TRUE(has(d.target, "/v1/collections/collection_x/documents?"));
ASSERT_TRUE(has(d.target, "name=paper.pdf"));
auto b = sent(r.mgmt_mock, [&] { svc.batch_get("collection_x", {"file_1", "file_2"}); });
ASSERT_TRUE(has(b.target, "documents:batchGet?file_ids=file_1&file_ids=file_2"));
refused(r.mgmt_mock, [&] { svc.batch_get("collection_x", {}); });
std::vector<std::string> many(PlatformCaps::kMaxBatchFileIds + 1, "f");
refused(r.mgmt_mock, [&] { svc.batch_get("collection_x", many); });
}
TEST(xai_platform_collections, documents_add_upload_and_guards) {
Rig r;
CollectionsService svc(r.mgmt);
Json fields = Json::object();
fields.set("author", "Sandra Kim");
auto a = sent(r.mgmt_mock, [&] { svc.add_document("collection_x", "file_y", fields); });
ASSERT_EQ(a.method, std::string("POST"));
ASSERT_TRUE(has(a.target, "/v1/collections/collection_x/documents/file_y"));
ASSERT_EQ(a.body, std::string("{\"fields\":{\"author\":\"Sandra Kim\"}}"));
auto u = sent(r.mgmt_mock, [&] { svc.upload_document("collection_x", "paper.pdf", "application/pdf", "PDF", fields); });
ASSERT_TRUE(has(u.target, "/v1/collections/collection_x/documents"));
ASSERT_TRUE(has(u.body, "name=\"data\"; filename=\"paper.pdf\""));
ASSERT_TRUE(has(u.body, "name=\"fields\""));
Json notobj = Json::array();
refused(r.mgmt_mock, [&] { svc.add_document("collection_x", "file_y", notobj); });
auto re = sent(r.mgmt_mock, [&] { svc.reindex_document("collection_x", "file_y"); });
ASSERT_EQ(re.method, std::string("PATCH"));
refused(r.mgmt_mock, [&] { svc.remove("collection_x", false); });
refused(r.mgmt_mock, [&] { svc.remove_document("collection_x", "file_y", false); });
auto d = sent(r.mgmt_mock, [&] { svc.remove_document("collection_x", "file_y", true); });
ASSERT_EQ(d.method, std::string("DELETE"));
auto c = sent(r.mgmt_mock, [&] { svc.remove("collection_x", true); });
ASSERT_EQ(c.method, std::string("DELETE"));
std::string big(PlatformCaps::kMaxCollectionDocBytes + 1, 'x');
refused(r.mgmt_mock, [&] { svc.upload_document("collection_x", "big.txt", "text/plain", big); });
// Collection management is the management host: the api client is refused.
CollectionsService wrong(r.api);
refused(r.api_mock, [&] { wrong.list(); });
}
TEST(xai_platform_search, body_matches_the_documented_example) {
Rig r;
DocumentSearch svc(r.api);
DocumentSearchRequest q;
q.query = "What were the key revenue drivers based on the SEC filings?";
q.collection_ids = {"collection_dbc087b1-6c99-493d-86c6-b401fee34a9d"};
q.retrieval_mode = "hybrid";
auto s = sent(r.api_mock, [&] { svc.search(q); });
ASSERT_TRUE(has(s.target, "/v1/documents/search"));
Json b = Json::parse(s.body);
ASSERT_EQ(b.find("source")->find("collection_ids")->as_array()[0].as_string(),
std::string("collection_dbc087b1-6c99-493d-86c6-b401fee34a9d"));
ASSERT_EQ(b.find("retrieval_mode")->find("type")->as_string(), std::string("hybrid"));
q.group_by = Json::object();
refused(r.api_mock, [&] { svc.search(q); });
DocumentSearchRequest none;
refused(r.api_mock, [&] { svc.search(none); });
none.query = "x";
refused(r.api_mock, [&] { svc.search(none); });
none.collection_ids = {"c"};
none.retrieval_mode = "fuzzy";
refused(r.api_mock, [&] { svc.search(none); });
none.retrieval_mode = "";
none.ranking_metric = "RANKING_METRIC_NONE";
refused(r.api_mock, [&] { svc.search(none); });
none.ranking_metric = "";
none.rag_pipeline = "solr";
refused(r.api_mock, [&] { svc.search(none); });
}
TEST(xai_platform_keys, create_matches_the_documented_example) {
Rig r;
ApiKeysService svc(r.mgmt);
ApiKeySpec spec;
spec.name = "My API key";
spec.acls = {"api-key:model:*", "api-key:endpoint:*"};
spec.qps = 5;
spec.qpm = 100;
spec.tpm = 100000;
auto s = sent(r.mgmt_mock, [&] { svc.create(kTeam, spec); });
ASSERT_TRUE(has(s.target, std::string("/auth/teams/") + kTeam + "/api-keys"));
Json b = Json::parse(s.body);
ASSERT_EQ(b.find("qps")->as_int(), 5L);
ASSERT_TRUE(b.find("tpm")->is_string()); // spec: tpm is a string
ASSERT_EQ(b.find("acls")->as_array().size(), static_cast<std::size_t>(2));
ApiKeySpec bad;
refused(r.mgmt_mock, [&] { svc.create(kTeam, bad); });
bad.name = "k";
bad.acls = {"admin:everything"};
refused(r.mgmt_mock, [&] { svc.create(kTeam, bad); });
bad.acls = {};
bad.qps = -1;
refused(r.mgmt_mock, [&] { svc.create(kTeam, bad); });
refused(r.mgmt_mock, [&] { svc.create("team-1", spec); });
}
TEST(xai_platform_keys, list_update_rotate_delete) {
Rig r;
ApiKeysService svc(r.mgmt);
auto l = sent(r.mgmt_mock, [&] { svc.list(kTeam, 10); });
ASSERT_TRUE(has(l.target, "pageSize=10"));
ASSERT_FALSE(has(l.target, "paginationToken")); // empty token is rejected by the server: never sent
auto l2 = sent(r.mgmt_mock, [&] { svc.list(kTeam, 10, "tok", true, {"api-key:model:grok-4"}); });
ASSERT_TRUE(has(l2.target, "paginationToken=tok"));
ASSERT_TRUE(has(l2.target, "activeOnly=true"));
ASSERT_TRUE(has(l2.target, "aclFilters=api-key%3Amodel%3Agrok-4"));
refused(r.mgmt_mock, [&] { svc.list_all(kTeam, 0); });
Json ch = Json::object();
Json inner = Json::object();
inner.set("qpm", Json(200));
ch = inner;
auto u = sent(r.mgmt_mock, [&] { svc.update(kKeyId, ch); });
ASSERT_EQ(u.method, std::string("PUT"));
ASSERT_EQ(u.body, std::string("{\"apiKey\":{\"qpm\":200},\"fieldMask\":\"qpm\"}"));
Json unknown = Json::object();
unknown.set("userId", "x");
refused(r.mgmt_mock, [&] { svc.update(kKeyId, unknown); });
refused(r.mgmt_mock, [&] { svc.update(kKeyId, Json::object()); });
refused(r.mgmt_mock, [&] { svc.rotate(kKeyId, false); });
auto ro = sent(r.mgmt_mock, [&] { svc.rotate(kKeyId, true, "2027-01-01T00:00:00Z", "2026-12-01T00:00:00Z"); });
ASSERT_TRUE(has(ro.target, "/rotate"));
ASSERT_TRUE(has(ro.body, "oldSecretExpireTime"));
refused(r.mgmt_mock, [&] { svc.remove(kKeyId, false); });
auto d = sent(r.mgmt_mock, [&] { svc.remove(kKeyId, true); });
ASSERT_EQ(d.method, std::string("DELETE"));
auto p = sent(r.mgmt_mock, [&] { svc.propagation(kKeyId); });
ASSERT_TRUE(has(p.target, "/propagation"));
auto m = sent(r.mgmt_mock, [&] { svc.team_models(kTeam); });
ASSERT_TRUE(has(m.target, "/models"));
auto e = sent(r.mgmt_mock, [&] { svc.team_endpoints(kTeam); });
ASSERT_TRUE(has(e.target, "/endpoints"));
auto v = sent(r.mgmt_mock, [&] { svc.validate_management_key(); });
ASSERT_TRUE(has(v.target, "/auth/management-keys/validation"));
}
TEST(xai_platform_billing, guards_amounts_and_bodies) {
Rig r;
BillingService svc(r.mgmt);
ASSERT_TRUE(BillingService::valid_amount("10"));
ASSERT_TRUE(BillingService::valid_amount("10.50"));
ASSERT_FALSE(BillingService::valid_amount("-1"));
ASSERT_FALSE(BillingService::valid_amount("1.234"));
ASSERT_FALSE(BillingService::valid_amount("1e3"));
ASSERT_FALSE(BillingService::valid_amount(""));
refused(r.mgmt_mock, [&] { svc.top_up(kTeam, "10", false); });
refused(r.mgmt_mock, [&] { svc.top_up(kTeam, "ten", true); });
auto t = sent(r.mgmt_mock, [&] { svc.top_up(kTeam, "10", true); });
ASSERT_EQ(t.body, std::string("{\"amount\":{\"val\":\"10\"}}"));
ASSERT_TRUE(has(t.target, "/prepaid/top-up"));
refused(r.mgmt_mock, [&] { svc.set_soft_spending_limit(kTeam, "100", false); });
auto sl = sent(r.mgmt_mock, [&] { svc.set_soft_spending_limit(kTeam, "100", true); });
ASSERT_EQ(sl.body, std::string("{\"desiredSoftSpendingLimit\":{\"val\":\"100\"}}"));
refused(r.mgmt_mock, [&] { svc.set_default_payment_method(kTeam, "pm_1", false); });
refused(r.mgmt_mock, [&] { svc.set_billing_info(kTeam, Json::object(), true); });
Json info = Json::object();
info.set("name", "Acme Inc.");
refused(r.mgmt_mock, [&] { svc.set_billing_info(kTeam, info, false); });
auto bi = sent(r.mgmt_mock, [&] { svc.set_billing_info(kTeam, info, true); });
ASSERT_EQ(bi.body, std::string("{\"billingInfo\":{\"name\":\"Acme Inc.\"}}"));
refused(r.mgmt_mock, [&] { svc.prepaid_balance("team"); });
auto pb = sent(r.mgmt_mock, [&] { svc.prepaid_balance(kTeam); });
ASSERT_TRUE(has(pb.target, "/prepaid/balance"));
}
TEST(xai_platform_billing, usage_invoices_and_audit) {
Rig r;
BillingService svc(r.mgmt);
// The documented usage request example.
Json range = Json::object();
range.set("startTime", "2025-10-01 00:00:00");
range.set("endTime", "2025-10-07 23:59:59");
range.set("timezone", "Etc/GMT");
Json val = Json::object();
val.set("name", "usd");
val.set("aggregation", "AGGREGATION_SUM");
Json vals = Json::array();
vals.push(val);
Json req = Json::object();
req.set("timeRange", range);
req.set("timeUnit", "TIME_UNIT_DAY");
req.set("values", vals);
auto u = sent(r.mgmt_mock, [&] { svc.usage(kTeam, req); });
ASSERT_TRUE(has(u.target, "/usage"));
ASSERT_TRUE(has(u.body, "\"analyticsRequest\""));
refused(r.mgmt_mock, [&] { svc.usage(kTeam, Json::object()); });
InvoiceQuery iq;
iq.cycle_year = 2026;
iq.cycle_month = 9;
auto inv = sent(r.mgmt_mock, [&] { svc.invoices(kTeam, iq); });
ASSERT_TRUE(has(inv.target, "billingCycle.year=2026&billingCycle.month=9"));
InvoiceQuery half;
half.since_year = 2026;
refused(r.mgmt_mock, [&] { svc.invoices(kTeam, half); });
AuditService audit(r.mgmt);
AuditQuery a;
a.page_size = 50;
a.time_from = "2025-01-01T00:00:00Z";
a.order_by = "TIME_DESCENDING";
a.user_id = "user-123";
auto e = sent(r.mgmt_mock, [&] { audit.events(kTeam, a); });
ASSERT_TRUE(has(e.target, "/audit/teams/" + std::string(kTeam) + "/events?"));
ASSERT_TRUE(has(e.target, "eventFilter.userId=user-123"));
ASSERT_TRUE(has(e.target, "eventTimeFrom=2025-01-01T00%3A00%3A00Z"));
AuditQuery bad;
bad.order_by = "RANDOM";
refused(r.mgmt_mock, [&] { audit.events(kTeam, bad); });
refused(r.mgmt_mock, [&] { audit.events_all(kTeam, 0); });
}
+432
View File
@@ -0,0 +1,432 @@
// xAI voice REST, session configuration builder, SIP phone numbers and the
// webhook verifier. Request bodies are checked against the documented
// examples; the SIP webhook body below is the example from the docs
// (docs.x.ai speech-to-speech/sip), verbatim.
#include "rig.h"
#include "xai/platform/realtime_rest.h"
#include "xai/platform/session_config.h"
#include "xai/platform/stt.h"
#include "xai/platform/tts.h"
#include "xai/platform/voices.h"
#include "xai/platform/webhook.h"
using namespace molo::xai::platform;
using namespace xai_test;
using molo::llm::ApiError;
using molo::clients::body::Json;
TEST(xai_platform_tts, body_and_caps) {
Rig r;
TextToSpeech svc(r.api);
TtsRequest q;
q.text = "Hello! [pause] Welcome.";
q.language = "en";
q.voice_id = "eve";
q.codec = "mp3";
q.sample_rate = 24000;
q.bit_rate = 128000;
q.speed = 1.2;
q.with_timestamps = true;
q.replace["Acme Mobile"] = "Acme Mobull";
auto s = sent(r.api_mock, [&] { svc.synthesize(q); });
ASSERT_TRUE(has(s.target, "/v1/tts"));
Json b = Json::parse(s.body);
ASSERT_EQ(b.find("text")->as_string(), std::string("Hello! [pause] Welcome."));
ASSERT_EQ(b.find("output_format")->find("codec")->as_string(), std::string("mp3"));
ASSERT_EQ(b.find("output_format")->find("bit_rate")->as_int(), 128000L);
ASSERT_TRUE(b.find("with_timestamps")->as_bool());
ASSERT_EQ(b.find("replace")->find("Acme Mobile")->as_string(), std::string("Acme Mobull"));
ASSERT_EQ(s.headers.get_or("Content-Type", ""), std::string("application/json"));
TtsRequest bad;
refused(r.api_mock, [&] { svc.synthesize(bad); });
bad.text = std::string(PlatformCaps::kMaxTtsChars + 1, 'a');
refused(r.api_mock, [&] { svc.synthesize(bad); });
bad.text = "x";
bad.language = "xx";
refused(r.api_mock, [&] { svc.synthesize(bad); });
bad.language = "EN"; // case-insensitive per docs
ASSERT_TRUE(svc.build(bad).find("language") != nullptr);
bad.codec = "ogg";
refused(r.api_mock, [&] { svc.synthesize(bad); });
bad.codec = "wav";
bad.bit_rate = 128000; // mp3 only
refused(r.api_mock, [&] { svc.synthesize(bad); });
bad.bit_rate = 0;
bad.speed = 2.0;
refused(r.api_mock, [&] { svc.synthesize(bad); });
bad.speed = 1.0;
bad.voice_id = "../x";
refused(r.api_mock, [&] { svc.synthesize(bad); });
}
TEST(xai_platform_stt, multipart_has_file_last_and_validates) {
Rig r;
SpeechToText svc(r.api);
SttRequest q;
q.data = "RIFFxxxx";
q.filename = "call.wav";
q.content_type = "audio/wav";
q.language = "en";
q.format = true;
q.diarize = true;
q.keyterms = {"Grok", "xAI"};
q.vad_threshold = 0.5;
auto s = sent(r.api_mock, [&] { svc.transcribe(q); });
ASSERT_TRUE(has(s.target, "/v1/stt"));
ASSERT_TRUE(has(s.headers.get_or("Content-Type", ""), "multipart/form-data"));
std::size_t file = s.body.find("name=\"file\"");
ASSERT_TRUE(file != std::string::npos);
for (const char* f : {"language", "format", "diarize", "keyterm", "vad_threshold"})
ASSERT_TRUE(s.body.find(std::string("name=\"") + f + "\"") < file);
ASSERT_EQ(part_value(s.body, "keyterm"), std::string("Grok"));
ASSERT_EQ(part_value(s.body, "language"), std::string("en"));
ASSERT_EQ(part_value(s.body, "file"), std::string("RIFFxxxx"));
SttRequest bad;
refused(r.api_mock, [&] { svc.transcribe(bad); }); // neither data nor url
bad.data = "x";
bad.url = "https://example.com/a.mp3";
refused(r.api_mock, [&] { svc.transcribe(bad); }); // both
bad.data = "";
bad.url = "ftp://example.com/a.mp3";
refused(r.api_mock, [&] { svc.transcribe(bad); });
bad.url = "https://example.com/a.mp3";
bad.format = true; // needs language
refused(r.api_mock, [&] { svc.transcribe(bad); });
bad.format = false;
bad.audio_format = "pcm"; // raw needs sample_rate
refused(r.api_mock, [&] { svc.transcribe(bad); });
bad.audio_format = "";
bad.keyterms.assign(PlatformCaps::kMaxKeyterms + 1, "k");
refused(r.api_mock, [&] { svc.transcribe(bad); });
bad.keyterms = {std::string(PlatformCaps::kMaxKeytermChars + 1, 'k')};
refused(r.api_mock, [&] { svc.transcribe(bad); });
bad.keyterms.clear();
bad.channels = 9;
refused(r.api_mock, [&] { svc.transcribe(bad); });
bad.channels = 0;
bad.vad_threshold = 1.5;
refused(r.api_mock, [&] { svc.transcribe(bad); });
auto u = sent(r.api_mock, [&] {
SttRequest ok;
ok.url = "https://example.com/a.mp3";
svc.transcribe(ok);
});
ASSERT_TRUE(has(u.body, "name=\"url\""));
ASSERT_FALSE(has(u.body, "name=\"file\""));
}
TEST(xai_platform_voices, custom_voice_rules) {
Rig r;
VoicesService svc(r.api);
auto l = sent(r.api_mock, [&] { svc.tts_voices(); });
ASSERT_TRUE(has(l.target, "/v1/tts/voices"));
auto g = sent(r.api_mock, [&] { svc.tts_voice("eve"); });
ASSERT_TRUE(has(g.target, "/v1/tts/voices/eve"));
CustomVoiceUpload up;
up.filename = "me.wav";
up.content_type = "audio/wav";
up.data = "RIFF";
up.name = "Me";
up.gender = "female";
up.use_case = "narration";
auto c = sent(r.api_mock, [&] { svc.create_custom(up); });
ASSERT_EQ(part_value(c.body, "gender"), std::string("female"));
ASSERT_TRUE(c.body.find("name=\"file\"") > c.body.find("name=\"gender\""));
up.gender = "robot";
refused(r.api_mock, [&] { svc.create_custom(up); });
up.gender = "";
up.tone = "angry";
refused(r.api_mock, [&] { svc.create_custom(up); });
auto ls = sent(r.api_mock, [&] { svc.list_custom(25, "tok"); });
ASSERT_TRUE(has(ls.target, "limit=25"));
refused(r.api_mock, [&] { svc.list_custom(1001); });
// PATCH: omitted stays, null clears, "" is rejected (spec).
Json ch = Json::object();
ch.set("accent", Json());
ch.set("name", "New");
auto p = sent(r.api_mock, [&] { svc.patch_custom("abcd1234", ch); });
ASSERT_EQ(p.method, std::string("PATCH"));
ASSERT_EQ(p.body, std::string("{\"accent\":null,\"name\":\"New\"}"));
Json empty = Json::object();
empty.set("name", "");
refused(r.api_mock, [&] { svc.patch_custom("abcd1234", empty); });
refused(r.api_mock, [&] { svc.patch_custom("abcd1234", Json::object()); });
Json unk = Json::object();
unk.set("audio", "x");
refused(r.api_mock, [&] { svc.patch_custom("abcd1234", unk); });
refused(r.api_mock, [&] { svc.remove_custom("abcd1234", false); });
auto d = sent(r.api_mock, [&] { svc.remove_custom("abcd1234", true); });
ASSERT_EQ(d.method, std::string("DELETE"));
auto a = sent(r.api_mock, [&] { svc.custom_audio("abcd1234"); });
ASSERT_TRUE(has(a.target, "/v1/custom-voices/abcd1234/audio"));
}
TEST(xai_platform_realtime_rest, client_secret_matches_the_documented_example) {
Rig r;
RealtimeRest svc(r.api);
ClientSecretRequest q;
q.expires_seconds = 300;
auto s = sent(r.api_mock, [&] { svc.client_secret(q); });
ASSERT_TRUE(has(s.target, "/v1/realtime/client_secrets"));
ASSERT_EQ(s.body, std::string("{\"expires_after\":{\"seconds\":300}}"));
ClientSecretRequest m;
m.model = "grok-voice-latest";
m.reasoning_effort = "none";
ASSERT_EQ(svc.build_client_secret(m).dump(),
std::string("{\"session\":{\"model\":\"grok-voice-latest\",\"reasoning\":{\"effort\":\"none\"}}}"));
ClientSecretRequest bad;
bad.expires_seconds = 3601;
refused(r.api_mock, [&] { svc.client_secret(bad); });
bad.expires_seconds = 0;
bad.model = "gpt-4o";
refused(r.api_mock, [&] { svc.client_secret(bad); });
bad.model = "";
bad.reasoning_effort = "low";
refused(r.api_mock, [&] { svc.client_secret(bad); });
}
TEST(xai_platform_realtime_rest, phone_numbers_and_call_control) {
Rig r;
RealtimeRest svc(r.api);
ASSERT_TRUE(RealtimeRest::valid_e164("+18005550199"));
ASSERT_FALSE(RealtimeRest::valid_e164("8005550199"));
ASSERT_FALSE(RealtimeRest::valid_e164("+1800555abcd"));
PhoneNumberSpec p;
p.name = "Support SIP trunk";
p.phone_number = "+18005550199";
p.allowed_addresses = {"203.0.113.0/24"};
p.webhook_url = "https://example.com/hook";
auto s = sent(r.api_mock, [&] { svc.create_phone_number(p); });
ASSERT_TRUE(has(s.target, "/v2/phone-numbers"));
Json b = Json::parse(s.body);
ASSERT_EQ(b.find("origin")->as_string(), std::string("byo_trunk"));
ASSERT_EQ(b.find("webhook")->find("url")->as_string(), std::string("https://example.com/hook"));
PhoneNumberSpec bad = p;
bad.agent_id = "agent_1"; // exclusive with webhook
refused(r.api_mock, [&] { svc.create_phone_number(bad); });
bad = p;
bad.phone_number = "123";
refused(r.api_mock, [&] { svc.create_phone_number(bad); });
bad = p;
bad.sip_username = "u"; // password missing
refused(r.api_mock, [&] { svc.create_phone_number(bad); });
bad = p;
bad.webhook_url = "http://example.com/hook";
refused(r.api_mock, [&] { svc.create_phone_number(bad); });
bad = p;
bad.area_code = "415"; // xai_provisioned only
refused(r.api_mock, [&] { svc.create_phone_number(bad); });
auto l = sent(r.api_mock, [&] { svc.list_phone_numbers(20, "", "agent_1"); });
ASSERT_TRUE(has(l.target, "limit=20&agent_id=agent_1"));
refused(r.api_mock, [&] { svc.list_phone_numbers(101); });
refused(r.api_mock, [&] { svc.remove_phone_number("phone_abc123", false); });
auto d = sent(r.api_mock, [&] { svc.remove_phone_number("phone_abc123", true); });
ASSERT_EQ(d.method, std::string("DELETE"));
refused(r.api_mock, [&] { svc.refer_call("call-1", "tel:+15551234567", false); });
refused(r.api_mock, [&] { svc.refer_call("call-1", "http://x", true); });
auto rf = sent(r.api_mock, [&] { svc.refer_call("call-1", "tel:+15551234567", true); });
ASSERT_TRUE(has(rf.target, "/v1/realtime/calls/call-1/refer"));
ASSERT_EQ(rf.body, std::string("{\"target_uri\":\"tel:+15551234567\"}"));
refused(r.api_mock, [&] { svc.hangup_call("call-1", false); });
auto h = sent(r.api_mock, [&] { svc.hangup_call("call-1", true); });
ASSERT_TRUE(has(h.target, "/hangup"));
}
TEST(xai_platform_session, builds_the_documented_session_update) {
SessionConfig c;
c.voice = "eve";
c.instructions = "You are a helpful phone support agent.";
c.turns = SessionConfig::Turns::kServerVad;
Json m = c.update_message();
ASSERT_EQ(m.dump(),
std::string("{\"session\":{\"instructions\":\"You are a helpful phone support agent.\","
"\"turn_detection\":{\"type\":\"server_vad\"},\"voice\":\"eve\"},"
"\"type\":\"session.update\"}"));
}
TEST(xai_platform_session, audio_tools_and_replace) {
SessionConfig c;
c.input.type = "audio/pcm";
c.input.rate = 16000;
c.input.transport = "binary";
c.output.type = "audio/pcmu";
c.language_hint = "pt-BR";
c.keyterms = {"Acme"};
c.output_speed = 1.1;
c.resumption = true;
c.reasoning_effort = "none";
c.idle_timeout_ms = 8000;
c.turns = SessionConfig::Turns::kServerVad;
c.tools.push_back(SessionTool::function("add", "adds", [] {
Json p = Json::object();
p.set("type", "object");
return p;
}()));
c.tools.push_back(SessionTool::web_search({"x.ai"}, {}, true, "US", "San Francisco"));
c.tools.push_back(SessionTool::x_search({"xai"}, {}, "2026-01-01", "2026-02-01"));
c.tools.push_back(SessionTool::file_search({"collection_x"}, 10));
c.tools.push_back(SessionTool::mcp("https://mcp.example.com/mcp", "my-tools", "d", {"a"}, "Bearer t", {{"X-A", "1"}}));
c.tools.push_back(SessionTool::send_dtmf());
c.replace["Acme Mobile"] = "Acme Mobull";
Json s = c.build();
ASSERT_EQ(s.find("audio")->find("input")->find("format")->find("rate")->as_int(), 16000L);
ASSERT_EQ(s.find("audio")->find("input")->find("transport")->as_string(), std::string("binary"));
ASSERT_EQ(s.find("audio")->find("input")->find("transcription")->find("language_hint")->as_string(), std::string("pt-BR"));
ASSERT_EQ(s.find("tools")->as_array().size(), static_cast<std::size_t>(6));
ASSERT_EQ(s.find("tools")->as_array()[1].find("location")->find("country")->as_string(), std::string("US"));
ASSERT_EQ(s.find("turn_detection")->find("idle_timeout_ms")->as_int(), 8000L);
ASSERT_TRUE(s.find("resumption")->find("enabled")->as_bool());
// Manual turns send turn_detection.type = null; clear_replace sends null.
SessionConfig man;
man.turns = SessionConfig::Turns::kManual;
man.clear_replace = true;
ASSERT_EQ(man.build().dump(), std::string("{\"replace\":null,\"turn_detection\":{\"type\":null}}"));
}
TEST(xai_platform_session, invalid_input_is_refused_before_sending) {
auto throws = [](SessionConfig c) {
try {
c.build();
} catch (const ApiError& e) {
return e.http_status() == 400;
}
return false;
};
SessionConfig c;
c.model = "gpt-realtime";
ASSERT_TRUE(throws(c));
c = {};
c.instructions = std::string(PlatformCaps::kMaxInstructionChars + 1, 'x');
ASSERT_TRUE(throws(c));
c = {};
c.input.type = "audio/mp3";
ASSERT_TRUE(throws(c));
c = {};
c.input.type = "audio/pcm";
c.input.rate = 12345;
ASSERT_TRUE(throws(c));
c = {};
c.output.type = "audio/opus";
c.output.rate = 24000; // rate is PCM only
ASSERT_TRUE(throws(c));
c = {};
c.language_hint = "es"; // regional variant required
ASSERT_TRUE(throws(c));
c = {};
c.keyterms.assign(PlatformCaps::kMaxKeyterms + 1, "k");
ASSERT_TRUE(throws(c));
c = {};
c.output_speed = 1.6;
ASSERT_TRUE(throws(c));
c = {};
c.turns = SessionConfig::Turns::kManual;
c.idle_timeout_ms = 100;
ASSERT_TRUE(throws(c));
c = {};
c.tools.push_back(Json::object());
ASSERT_TRUE(throws(c));
c = {};
c.replace["a"] = "b";
c.clear_replace = true;
ASSERT_TRUE(throws(c));
ASSERT_THROW(SessionTool::web_search({"a.com"}, {"b.com"}), ApiError);
ASSERT_THROW(SessionTool::web_search({"1", "2", "3", "4", "5", "6"}), ApiError);
ASSERT_THROW(SessionTool::x_search({}, {}, "2026-02-01", "2026-01-01"), ApiError);
ASSERT_THROW(SessionTool::x_search({}, {}, "01/02/2026"), ApiError);
ASSERT_THROW(SessionTool::mcp("ftp://x", "l"), ApiError);
ASSERT_THROW(SessionTool::function("bad name!", "", Json::object()), ApiError);
ASSERT_THROW(SessionTool::file_search({}), ApiError);
}
TEST(xai_platform_webhook, hmac_sha256_known_answers) {
// RFC 4231 test case 1 and 2.
auto hex = [](const std::string& raw) {
static const char* d = "0123456789abcdef";
std::string o;
for (unsigned char c : raw) {
o.push_back(d[c >> 4]);
o.push_back(d[c & 15]);
}
return o;
};
ASSERT_EQ(hex(WebhookVerifier::hmac_sha256(std::string(20, '\x0b'), "Hi There")),
std::string("b0344c61d8db38535ca8afceaf0bf12b881dc200c9833da726e9376c2e32cff7"));
ASSERT_EQ(hex(WebhookVerifier::hmac_sha256("Jefe", "what do ya want for nothing?")),
std::string("5bdcc146bf60754e6a042426089575c75a003f089d2739839dec58b964ec3843"));
// Key longer than the block size (RFC 4231 case 6).
ASSERT_EQ(hex(WebhookVerifier::hmac_sha256(std::string(131, '\xaa'),
"Test Using Larger Than Block-Size Key - Hash Key First")),
std::string("60e431591ee0b67f0d8a26aacbf5b77f8e0bc6213728c5140546040f0ee37f54"));
}
namespace {
// The webhook example from the SIP docs, verbatim.
const char* kSipWebhook =
"{\n \"object\": \"event\",\n \"id\": \"evt_123\",\n \"type\": \"realtime.call.incoming\",\n"
" \"created_at\": 1750000000,\n \"data\": {\n"
" \"call_id\": \"00000000-0000-0000-0000-000000000000\",\n"
" \"sip_headers\": [\n { \"name\": \"From\", \"value\": \"+14155550100\" },\n"
" { \"name\": \"To\", \"value\": \"+18005550199\" }\n ],\n \"metadata\": {}\n }\n}";
// whsec_ + base64("0123456789abcdef0123456789abcdef")
const char* kSecret = "whsec_MDEyMzQ1Njc4OWFiY2RlZjAxMjM0NTY3ODlhYmNkZWY=";
} // namespace
TEST(xai_platform_webhook, verifies_signed_incoming_call) {
WebhookVerifier v(kSecret);
WebhookHeaders h;
h.id = "msg_1";
h.timestamp = "1750000000";
h.signature = v.sign(h, kSipWebhook);
ASSERT_TRUE(h.signature.rfind("v1,", 0) == 0);
IncomingCall call = v.parse_incoming(h, kSipWebhook, 1750000100);
ASSERT_EQ(call.call_id, std::string("00000000-0000-0000-0000-000000000000"));
ASSERT_EQ(call.type, std::string("realtime.call.incoming"));
// Key rotation: several signatures, one valid.
WebhookHeaders rot = h;
rot.signature = "v1,AAAA " + h.signature;
v.verify(rot, kSipWebhook, 1750000000);
}
TEST(xai_platform_webhook, rejects_tampering_replays_and_bad_secrets) {
WebhookVerifier v(kSecret);
WebhookHeaders h;
h.id = "msg_1";
h.timestamp = "1750000000";
h.signature = v.sign(h, kSipWebhook);
auto rejected = [&](const WebhookHeaders& hh, const std::string& body, long now) {
try {
v.verify(hh, body, now);
} catch (const ApiError& e) {
return e.http_status() == 401 && e.type() == "webhook_invalid";
}
return false;
};
ASSERT_TRUE(rejected(h, std::string(kSipWebhook) + " ", 1750000000)); // body changed
ASSERT_TRUE(rejected(h, kSipWebhook, 1750000000 + 301)); // too old
ASSERT_TRUE(rejected(h, kSipWebhook, 1750000000 - 301)); // from the future
WebhookHeaders other = h;
other.id = "msg_2";
ASSERT_TRUE(rejected(other, kSipWebhook, 1750000000)); // id is signed
other = h;
other.timestamp = "abc";
ASSERT_TRUE(rejected(other, kSipWebhook, 1750000000));
other = h;
other.signature = "";
ASSERT_TRUE(rejected(other, kSipWebhook, 1750000000));
other = h;
other.signature = "v2,abc";
ASSERT_TRUE(rejected(other, kSipWebhook, 1750000000));
ASSERT_THROW(WebhookVerifier("whsec_!!!"), ApiError);
ASSERT_THROW(WebhookVerifier(""), ApiError);
// A valid signature on a different event type is not an incoming call.
std::string other_body = "{\"type\":\"realtime.call.ended\",\"data\":{\"call_id\":\"c\"}}";
WebhookHeaders oh = h;
oh.signature = v.sign(oh, other_body);
ASSERT_THROW(v.parse_incoming(oh, other_body, 1750000000), ApiError);
ASSERT_THROW(v.verify(h, std::string(PlatformCaps::kMaxWebhookBodyBytes + 1, 'x'), 1750000000), ApiError);
}
+384
View File
@@ -0,0 +1,384 @@
// xAI voice sockets over a test-owned loopback WebSocket server (RFC 6455
// framing, plain ws://). The server plays the documented message flows
// (docs.x.ai voice-realtime, tts-streaming, stt-streaming .ws.json); the
// tests check what the client puts on the wire and how it folds events.
#include "../../google/live/loopback.h"
#include "rig.h"
#include "security/crypto/Base64.h"
#include "xai/platform/realtime_session.h"
#include "xai/platform/stt_stream.h"
#include "xai/platform/tts_stream.h"
using namespace molo::xai::platform;
using namespace xai_test;
using live_test::LoopbackServer;
using live_test::ServerConn;
using molo::llm::ApiError;
using molo::clients::body::Json;
using molo::security::crypto::Base64;
namespace {
SocketOptions fast() {
SocketOptions o;
o.max_session_seconds = 20;
return o;
}
void created(ServerConn& c) {
c.send_text("{\"event_id\":\"e1\",\"type\":\"session.created\",\"session\":{\"id\":\"s1\",\"object\":\"realtime.session\",\"model\":\"grok-voice-3.0\"}}");
c.send_text("{\"event_id\":\"e0\",\"type\":\"conversation.created\",\"conversation\":{\"id\":\"conv_1\",\"object\":\"realtime.conversation\"}}");
}
// First line of the handshake request.
std::string request_line(const std::string& req) { return req.substr(0, req.find("\r\n")); }
Json read_json(ServerConn& c) {
auto m = c.read_message();
if (!m) throw std::runtime_error("client sent nothing");
return Json::parse(*m);
}
RealtimeOptions rt_options(const LoopbackServer& s) {
RealtimeOptions o;
o.url = s.url("/v1/realtime");
o.socket = fast();
return o;
}
} // namespace
TEST(xai_platform_ws, realtime_flow_headers_and_folding) {
std::string seen_update;
LoopbackServer server([&](ServerConn& c) {
created(c);
Json up = read_json(c);
seen_update = up.dump();
c.send_text("{\"type\":\"session.updated\",\"session\":{\"id\":\"s1\",\"voice\":\"eve\"}}");
Json item = read_json(c); // conversation.item.create
Json rsp = read_json(c); // response.create
c.send_text("{\"type\":\"response.created\",\"response\":{\"id\":\"resp_1\",\"object\":\"realtime.response\",\"status\":\"in_progress\"}}");
c.send_text("{\"type\":\"response.output_audio_transcript.delta\",\"response_id\":\"resp_1\",\"delta\":\"Hel\"}");
c.send_text("{\"type\":\"response.output_audio_transcript.delta\",\"response_id\":\"resp_1\",\"delta\":\"lo\"}");
c.send_text("{\"type\":\"response.output_audio.delta\",\"response_id\":\"resp_1\",\"delta\":\"" + Base64::encode(std::string("\x01\x02\x03", 3)) + "\"}");
c.send_text("{\"type\":\"response.output_audio.delta\",\"response_id\":\"resp_1\",\"delta\":\"" + Base64::encode(std::string("\x04", 1)) + "\"}");
c.send_text("{\"type\":\"response.done\",\"response\":{\"id\":\"resp_1\",\"status\":\"completed\",\"usage\":{\"input_tokens\":5,\"output_tokens\":7,\"total_tokens\":12}}}");
(void)item;
(void)rsp;
});
RealtimeOptions o = rt_options(server);
o.model = "grok-voice-latest";
o.reasoning_effort = "none";
RealtimeSession s("KEY-123", o);
ASSERT_TRUE(has(s.url(), "model=grok-voice-latest"));
ASSERT_TRUE(has(s.url(), "reasoning.effort=none"));
s.connect();
ASSERT_EQ(s.conversation_id(), std::string("conv_1"));
ASSERT_EQ(s.setup_events().size(), static_cast<std::size_t>(2));
SessionConfig cfg;
cfg.voice = "eve";
cfg.turns = SessionConfig::Turns::kServerVad;
s.update_session(cfg);
auto upd = s.next(2000);
ASSERT_TRUE(upd && upd->type == "session.updated" && upd->known);
s.add_user_text("Say hello");
s.create_response();
RealtimeResponse r = s.run_response(3000);
ASSERT_EQ(r.response_id, std::string("resp_1"));
ASSERT_EQ(r.transcript, std::string("Hello"));
ASSERT_EQ(r.audio, std::string("\x01\x02\x03\x04", 4));
ASSERT_EQ(r.status, std::string("completed"));
ASSERT_EQ(r.usage.find("total_tokens")->as_int(), 12L);
ASSERT_TRUE(r.errors.empty());
ASSERT_EQ(s.counters().unknown_events, static_cast<std::size_t>(0));
s.close();
// Wire: key only in the Authorization header, never in the request line.
std::string req = server.request();
ASSERT_TRUE(has(req, "Authorization: Bearer KEY-123"));
ASSERT_FALSE(has(request_line(req), "KEY-123"));
ASSERT_TRUE(has(request_line(req), "GET /v1/realtime?model=grok-voice-latest&reasoning.effort=none"));
ASSERT_EQ(seen_update,
std::string("{\"session\":{\"turn_detection\":{\"type\":\"server_vad\"},\"voice\":\"eve\"},\"type\":\"session.update\"}"));
}
TEST(xai_platform_ws, ephemeral_secret_goes_in_the_subprotocol) {
LoopbackServer server([&](ServerConn& c) { created(c); });
RealtimeOptions o = rt_options(server);
o.auth = SocketAuth::kClientSecretProtocol;
RealtimeSession s("SECRET-XYZ", o);
try {
s.connect();
} catch (const ApiError&) {
// The loopback does not echo the subprotocol; a strict client may reject.
}
std::string req = server.request();
ASSERT_TRUE(has(req, "Sec-WebSocket-Protocol: xai-client-secret.SECRET-XYZ"));
ASSERT_FALSE(has(req, "Authorization:"));
}
TEST(xai_platform_ws, function_call_roundtrip_and_client_messages) {
std::vector<std::string> got;
LoopbackServer server([&](ServerConn& c) {
created(c);
c.send_text("{\"type\":\"response.function_call_arguments.done\",\"response_id\":\"r\",\"item_id\":\"i1\",\"call_id\":\"call_9\",\"name\":\"add\",\"arguments\":\"{\\\"a\\\":1}\"}");
c.send_text("{\"type\":\"response.done\",\"response\":{\"id\":\"r\",\"status\":\"completed\"}}");
for (int i = 0; i < 9; ++i) {
auto m = c.read_message();
if (!m) break;
got.push_back(*m);
}
});
RealtimeSession s("K", rt_options(server));
s.connect();
RealtimeResponse r = s.run_response(3000);
ASSERT_EQ(r.calls.size(), static_cast<std::size_t>(1));
ASSERT_EQ(r.calls[0].call_id, std::string("call_9"));
ASSERT_EQ(r.calls[0].name, std::string("add"));
ASSERT_EQ(r.calls[0].arguments, std::string("{\"a\":1}"));
s.add_function_output("call_9", "2");
s.create_response();
s.append_audio("abc");
s.commit_audio();
s.clear_audio();
s.force_message("This call is recorded.", false);
s.truncate_item("item_1", 0, 1500);
s.cancel_response("resp_1");
s.delete_item("item_1");
s.close();
// Wait for the server thread to read everything.
for (int i = 0; i < 100 && got.size() < 9; ++i) std::this_thread::sleep_for(std::chrono::milliseconds(20));
ASSERT_EQ(got.size(), static_cast<std::size_t>(9));
ASSERT_EQ(got[0], std::string("{\"item\":{\"call_id\":\"call_9\",\"output\":\"2\",\"type\":\"function_call_output\"},\"type\":\"conversation.item.create\"}"));
ASSERT_EQ(got[1], std::string("{\"type\":\"response.create\"}"));
ASSERT_EQ(got[2], std::string("{\"audio\":\"YWJj\",\"type\":\"input_audio_buffer.append\"}"));
ASSERT_EQ(got[3], std::string("{\"type\":\"input_audio_buffer.commit\"}"));
ASSERT_EQ(got[4], std::string("{\"type\":\"input_audio_buffer.clear\"}"));
ASSERT_TRUE(has(got[5], "\"type\":\"force_message\"") && has(got[5], "\"interruptible\":false"));
ASSERT_EQ(got[6], std::string("{\"audio_end_ms\":1500,\"content_index\":0,\"item_id\":\"item_1\",\"type\":\"conversation.item.truncate\"}"));
ASSERT_EQ(got[7], std::string("{\"response_id\":\"resp_1\",\"type\":\"response.cancel\"}"));
ASSERT_EQ(got[8], std::string("{\"item_id\":\"item_1\",\"type\":\"conversation.item.delete\"}"));
}
TEST(xai_platform_ws, binary_transport_sends_raw_frames) {
std::string payload;
LoopbackServer server([&](ServerConn& c) {
created(c);
auto f = c.read_frame();
if (f) payload = f->payload;
c.send_binary("RAW-AUDIO");
c.send_text("{\"type\":\"response.done\",\"response\":{\"id\":\"r\",\"status\":\"completed\"}}");
});
RealtimeSession s("K", rt_options(server));
s.connect();
s.set_input_binary(true);
s.append_audio("PCM!");
RealtimeResponse r = s.run_response(3000);
ASSERT_EQ(r.audio, std::string("RAW-AUDIO"));
ASSERT_EQ(payload, std::string("PCM!"));
ASSERT_EQ(s.counters().binary_frames, static_cast<std::size_t>(1));
}
TEST(xai_platform_ws, setup_failures_are_loud) {
{
LoopbackServer server([&](ServerConn& c) {
c.send_text("{\"type\":\"error\",\"error\":{\"type\":\"invalid_request_error\",\"message\":\"nope\"}}");
});
RealtimeSession s("K", rt_options(server));
ASSERT_THROW(s.connect(), ApiError);
ASSERT_FALSE(s.is_open());
}
{
LoopbackServer server([&](ServerConn&) {}, LoopbackServer::Handshake::Status403);
RealtimeSession s("K", rt_options(server));
try {
s.connect();
FAIL("expected ApiError");
} catch (const ApiError& e) {
ASSERT_EQ(e.http_status(), 403);
ASSERT_EQ(e.type(), std::string("authentication_error"));
ASSERT_FALSE(has(e.message(), "K" "EY"));
}
}
{
LoopbackServer server([&](ServerConn&) {}, LoopbackServer::Handshake::BadAccept);
RealtimeSession s("K", rt_options(server));
ASSERT_THROW(s.connect(), ApiError);
}
RealtimeOptions o;
o.model = "gpt-realtime";
ASSERT_THROW(RealtimeSession("K", o), ApiError);
o = {};
o.call_id = "../x";
ASSERT_THROW(RealtimeSession("K", o), ApiError);
RealtimeSession nokey("", RealtimeOptions());
ASSERT_THROW(nokey.connect(), ApiError);
}
TEST(xai_platform_ws, unknown_events_and_bad_audio_are_counted_or_refused) {
LoopbackServer server([&](ServerConn& c) {
created(c);
c.send_text("{\"type\":\"made.up.event\"}");
c.send_text("not json at all");
c.send_text("{\"type\":\"response.output_audio.delta\",\"delta\":\"!!!not base64!!!\"}");
});
RealtimeSession s("K", rt_options(server));
s.connect();
auto a = s.next(2000);
ASSERT_TRUE(a && a->type == "made.up.event" && !a->known);
auto b = s.next(2000);
ASSERT_TRUE(b && !b->known && b->type.empty());
ASSERT_THROW(s.next(2000), ApiError);
ASSERT_EQ(s.counters().unknown_events, static_cast<std::size_t>(1));
ASSERT_TRUE(s.counters().decode_errors >= 2);
}
TEST(xai_platform_ws, local_validation_never_touches_the_socket) {
LoopbackServer server([&](ServerConn& c) { created(c); });
RealtimeSession s("K", rt_options(server));
s.connect();
ASSERT_THROW(s.append_audio(""), ApiError);
ASSERT_THROW(s.append_audio(std::string(PlatformCaps::kMaxAudioChunkBytes + 1, 'x')), ApiError);
ASSERT_THROW(s.add_user_text(""), ApiError);
ASSERT_THROW(s.add_user_text(std::string(PlatformCaps::kMaxItemTextChars + 1, 'x')), ApiError);
ASSERT_THROW(s.add_function_output("bad id!", "x"), ApiError);
ASSERT_THROW(s.truncate_item("i", -1, 0), ApiError);
ASSERT_THROW(s.delete_item("../x"), ApiError);
ASSERT_EQ(s.counters().sent, static_cast<std::size_t>(0));
}
TEST(xai_platform_ws, tts_stream_utterance) {
std::vector<std::string> got;
LoopbackServer server([&](ServerConn& c) {
for (int i = 0; i < 3; ++i) {
auto m = c.read_message();
if (!m) return;
got.push_back(*m);
}
c.send_text("{\"type\":\"audio.delta\",\"delta\":\"" + Base64::encode(std::string("AB")) +
"\",\"audio_timestamps\":{\"graph_chars\":[\"H\",\"i\"],\"graph_times\":[[0.0,0.06],[0.06,0.12]]},\"audio_duration\":0.12}");
c.send_text("{\"type\":\"audio.delta\",\"delta\":\"" + Base64::encode(std::string("CD")) + "\"}");
c.send_text("{\"type\":\"audio.done\",\"trace_id\":\"550e8400-e29b-41d4-a716-446655440000\"}");
});
TtsStreamOptions o;
o.url = server.url("/v1/tts");
o.language = "en";
o.voice = "eve";
o.codec = "pcm";
o.sample_rate = 24000;
o.with_timestamps = true;
o.socket = fast();
TtsStream s("KEY-TTS", o);
ASSERT_TRUE(has(s.url(), "language=en"));
ASSERT_TRUE(has(s.url(), "codec=pcm&sample_rate=24000"));
s.connect();
s.send_text("Hello! ");
s.send_text("Welcome.");
s.finish_utterance();
TtsUtterance u = s.collect(3000);
ASSERT_TRUE(u.complete);
ASSERT_EQ(u.audio, std::string("ABCD"));
ASSERT_EQ(u.chunks, static_cast<std::size_t>(2));
ASSERT_EQ(u.trace_id, std::string("550e8400-e29b-41d4-a716-446655440000"));
ASSERT_EQ(u.chunk_timestamps.size(), static_cast<std::size_t>(1));
ASSERT_EQ(got[0], std::string("{\"delta\":\"Hello! \",\"type\":\"text.delta\"}"));
ASSERT_EQ(got[2], std::string("{\"type\":\"text.done\"}"));
ASSERT_TRUE(has(server.request(), "Authorization: Bearer KEY-TTS"));
ASSERT_THROW(s.send_text(std::string(PlatformCaps::kMaxTextDeltaChars + 1, 'x')), ApiError);
ASSERT_THROW(s.send_text(""), ApiError);
}
TEST(xai_platform_ws, tts_stream_options_and_errors) {
TtsStreamOptions o;
o.language = "klingon";
ASSERT_THROW(TtsStream("K", o), ApiError);
o.language = "en";
o.speed = 3;
ASSERT_THROW(TtsStream("K", o), ApiError);
o.speed = 1;
o.codec = "wav";
o.bit_rate = 128000;
ASSERT_THROW(TtsStream("K", o), ApiError);
o = {};
o.optimize_streaming_latency = 2; // the socket documents 0 and 1 only
ASSERT_THROW(TtsStream("K", o), ApiError);
LoopbackServer server([&](ServerConn& c) {
c.read_message();
c.send_text("{\"type\":\"error\",\"message\":\"TTS failed: internal error\"}");
});
TtsStreamOptions ok;
ok.url = server.url("/v1/tts");
ok.socket = fast();
TtsStream s("K", ok);
s.connect();
TtsUtterance u = s.speak("hi", 3000);
ASSERT_FALSE(u.complete);
ASSERT_EQ(u.error, std::string("TTS failed: internal error"));
}
TEST(xai_platform_ws, stt_stream_partials_and_done) {
std::vector<std::string> texts;
std::string audio;
LoopbackServer server([&](ServerConn& c) {
c.send_text("{\"type\":\"transcript.created\",\"id\":\"tr_1\"}");
for (;;) {
auto f = c.read_frame();
if (!f) return;
if (f->opcode == 2) {
audio += f->payload;
c.send_text("{\"type\":\"transcript.partial\",\"text\":\"hel\",\"words\":[],\"is_final\":false,\"speech_final\":false,\"start\":0.0,\"duration\":0.4}");
} else if (f->opcode == 1) {
texts.push_back(f->payload);
if (f->payload.find("audio.done") != std::string::npos) {
c.send_text("{\"type\":\"transcript.done\",\"text\":\"hello world\",\"words\":[{\"text\":\"hello\",\"start\":0.0,\"end\":0.4}],\"duration\":1.2}");
return;
}
}
}
});
SttStreamOptions o;
o.url = server.url("/v1/stt");
o.sample_rate = 16000;
o.encoding = "pcm";
o.interim_results = true;
o.language = "en";
o.keyterms = {"Grok"};
o.socket = fast();
SttStream s("KEY-STT", o);
ASSERT_TRUE(has(s.url(), "sample_rate=16000&encoding=pcm&interim_results=true"));
ASSERT_TRUE(has(s.url(), "keyterm=Grok"));
s.connect();
ASSERT_EQ(s.transcript_id(), std::string("tr_1"));
s.send_audio("aaaa");
s.send_audio("bbbb");
s.finalize();
s.finish();
Transcript t = s.collect(3000);
ASSERT_TRUE(t.complete);
ASSERT_EQ(t.text, std::string("hello world"));
ASSERT_EQ(t.partials.size(), static_cast<std::size_t>(2));
ASSERT_EQ(audio, std::string("aaaabbbb"));
ASSERT_EQ(texts[0], std::string("{\"type\":\"finalize\"}"));
ASSERT_EQ(texts[1], std::string("{\"type\":\"audio.done\"}"));
ASSERT_THROW(s.send_audio(""), ApiError);
SttStreamOptions bad;
bad.format = true; // needs language
ASSERT_THROW(SttStream("K", bad), ApiError);
bad = {};
bad.encoding = "mp3";
ASSERT_THROW(SttStream("K", bad), ApiError);
bad = {};
bad.vad_threshold = 2;
ASSERT_THROW(SttStream("K", bad), ApiError);
}
TEST(xai_platform_ws, vocabulary_rejects_unknown_client_messages) {
LoopbackServer server([&](ServerConn& c) { created(c); });
RealtimeSession s("K", rt_options(server));
s.connect();
ASSERT_TRUE(WsVocabulary::known_client("realtime", "session.update"));
ASSERT_TRUE(WsVocabulary::known_server("realtime", "response.done"));
ASSERT_FALSE(WsVocabulary::known_client("realtime", "response.done"));
ASSERT_TRUE(WsVocabulary::known_server("tts", "audio.done"));
ASSERT_TRUE(WsVocabulary::known_server("stt", "transcript.done"));
ASSERT_TRUE(WsVocabulary::count() > 100);
}