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:
@@ -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
|
||||
@@ -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);
|
||||
}
|
||||
@@ -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); });
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
Reference in New Issue
Block a user