feat(clients): anthropic admin: Admin API, reports, managed agents table, demo and tests

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-10-24 07:46:48 +02:00
co-authored by Claude Sonnet 5.5
parent 2e0270c043
commit 04c2d7f20c
64 changed files with 7703 additions and 3 deletions
@@ -0,0 +1,34 @@
// Route: POST /ai/anthropic/admin/call (validate, dry run for writes, 503 without credential)
#include "support/Assert.hpp"
using namespace molo::example::test;
static const char* kJson = "application/json";
int main() {
Fixture f;
auto post = [&](const std::string& body) { return f.client->post("/ai/anthropic/admin/call", body, kJson); };
check(post("{\"call\":\"organization.invites.list\"}").status == 503, "read without credential is 503");
check(contains(post("{\"call\":\"organization.invites.list\"}").body, "not_configured"), "503 code is not_configured");
check(post("{}").status == 422, "missing call is 422");
check(post("{\"call\":\"nope.nothing\"}").status == 422, "unknown call is 422");
check(post("{\"call\":\"organization.invites.retrieve\"}").status == 422, "missing id is 422");
check(post("{\"call\":\"organization.invites.retrieve\",\"ids\":[\"a/b\"]}").status == 422, "bad id is 422");
check(post("{\"call\":\"organization.invites.list\",\"query\":{\"bogus\":1}}").status == 422, "unknown query param is 422");
check(post("{\"call\":\"organization.invites.list\",\"query\":{\"limit\":5000}}").status == 422, "limit over cap is 422");
check(post("{\"call\":\"organization.invites.create\",\"body\":{\"email\":\"a@b.c\"}}").status == 422, "missing required field is 422");
check(post("{\"call\":\"organization.invites.create\",\"body\":{\"email\":\"a@b.c\",\"role\":\"user\",\"x\":1}}").status == 422, "unknown field is 422");
check(post("{\"call\":\"sessions.events.stream\",\"ids\":[\"s1\"]}").status == 422, "stream calls are refused here");
check(post("not json").status == 422, "bad JSON is 422");
// writes and deletes are dry runs without confirm, even without a credential
auto dry = post("{\"call\":\"organization.invites.create\",\"body\":{\"email\":\"a@b.c\",\"role\":\"user\"}}");
check(dry.status == 200 && contains(dry.body, "\"dry_run\":true"), "create is a dry run");
auto del = post("{\"call\":\"organization.users.remove\",\"ids\":[\"user_01\"]}");
check(del.status == 200 && contains(del.body, "\"dry_run\":true") && contains(del.body, "DELETE"), "remove user is a dry run");
auto confirmed = post("{\"call\":\"organization.users.remove\",\"ids\":[\"user_01\"],\"confirm\":true}");
check(confirmed.status == 503, "confirmed delete without credential is 503");
check(post("{\"call\":\"organization.users.remove\",\"ids\":[\"user_01\"],\"confirm\":\"yes\"}").status == 422, "non-bool confirm is 422");
check(f.client->get("/ai/anthropic/admin/call").status == 405, "get is 405");
return finish("ai/anthropic/admin/call");
}
@@ -0,0 +1,24 @@
// Routes: GET /ai/anthropic/admin, /status, /calls (no credential needed)
#include "support/Assert.hpp"
using namespace molo::example::test;
int main() {
Fixture f;
auto page = f.client->get("/ai/anthropic/admin");
check(page.status == 200, "page is 200");
check(contains(page.headers.get("Content-Type"), "text/html"), "html");
check(contains(page.body, "Anthropic admin") && contains(page.body, "viewport"), "title and mobile viewport");
check(contains(page.body, "/embedded/ai_anthropic_admin.js"), "script wired");
check(f.client->post("/ai/anthropic/admin", "{}", "application/json").status == 405, "post is 405");
auto st = f.client->get("/ai/anthropic/admin/status");
check(st.status == 200 && contains(st.body, "\"admin_key\"") && contains(st.body, "\"api_version\""), "status lists the lanes");
check(!contains(st.body, "sk-ant"), "status never shows a key");
check(f.client->post("/ai/anthropic/admin/status", "{}", "application/json").status == 405, "status post is 405");
auto calls = f.client->get("/ai/anthropic/admin/calls");
check(calls.status == 200 && contains(calls.body, "organization.invites.create") &&
contains(calls.body, "usage_report.retrieve_messages"), "call table is listed");
return finish("ai/anthropic/admin/page");
}
@@ -0,0 +1,32 @@
// Routes: POST /ai/anthropic/admin/{organization,usage,cost,claude-code,webhook/verify}
#include "support/Assert.hpp"
using namespace molo::example::test;
static const char* kJson = "application/json";
int main() {
Fixture f;
auto post = [&](const std::string& path, const std::string& body) { return f.client->post("/ai/anthropic/admin" + path, body, kJson); };
check(post("/organization", "{}").status == 503, "organization without credential is 503");
check(post("/usage", "{\"starting_at\":\"2026-10-01T00:00:00Z\"}").status == 503, "usage without credential is 503");
check(post("/usage", "{}").status == 422, "usage without starting_at is 422");
check(post("/usage", "{\"starting_at\":\"yesterday\"}").status == 422, "bad timestamp is 422");
check(post("/usage", "{\"starting_at\":\"2026-10-01T00:00:00Z\",\"limit\":32}").status == 422, "limit over 31 days is 422");
check(post("/usage", "{\"starting_at\":\"2026-10-01T00:00:00Z\",\"bucket_width\":\"5m\"}").status == 422, "bad bucket width is 422");
check(post("/cost", "{\"starting_at\":\"2026-10-01T00:00:00Z\"}").status == 503, "cost without credential is 503");
check(post("/cost", "{\"starting_at\":\"2026-10-01T00:00:00Z\",\"group_by\":[\"model\"]}").status == 422, "cost group_by model is 422");
check(post("/claude-code", "{\"starting_at\":\"2026-10-01\"}").status == 503, "claude code without credential is 503");
check(post("/claude-code", "{\"starting_at\":\"2026-10-01T00:00:00Z\"}").status == 422, "claude code needs a date");
check(post("/claude-code", "{\"starting_at\":\"2026-10-01\",\"limit\":1001}").status == 422, "claude code limit over 1000 is 422");
// local signature check, Standard Webhooks published key (timestamp is old: outside tolerance)
auto v = post("/webhook/verify", "{\"signing_key\":\"whsec_MfKQ9r8GKYqrTwjUPD8ILPZIo2LaLaSw\",\"payload\":\"{}\","
"\"webhook_id\":\"m\",\"webhook_timestamp\":\"1614265330\",\"webhook_signature\":\"v1,AAAA\"}");
check(v.status == 200 && contains(v.body, "\"valid\":false"), "bad signature is reported, not an error");
check(post("/webhook/verify", "{\"signing_key\":\"%%%\",\"payload\":\"{}\"}").status == 422, "bad signing key is 422");
check(post("/webhook/verify", "{}").status == 422, "missing key is 422");
for (const char* p : {"/organization", "/usage", "/cost", "/claude-code", "/webhook/verify"})
check(f.client->get(std::string("/ai/anthropic/admin") + p).status == 405, std::string("get ") + p + " is 405");
return finish("ai/anthropic/admin/report");
}
+464
View File
@@ -0,0 +1,464 @@
// Anthropic admin package: deterministic local tests. No vendor reply is
// scripted: tests cover the call table, request building, credential lanes,
// caps, paging rules, report queries and parsing of documented examples
// (fixtures copied verbatim from platform.claude.com/docs/en/api, marked),
// and webhook signatures against the Standard Webhooks published vector.
// Opt-in live read-only checks at the end (MOLO_LIVE_NET=1 plus a key).
#include <cstdlib>
#include <iostream>
#include <set>
#include "framework.h"
#include "anthropic/admin/api.h"
#include "anthropic/admin/reports.h"
#include "anthropic/admin/request.h"
#include "anthropic/admin/webhook.h"
#include "clients/transports/mock_transport.h"
#include "llm/config.h"
using namespace molo::anthropic::admin;
using molo::clients::body::Json;
using molo::clients::transports::MockTransport;
using molo::llm::ApiError;
using molo::llm::NotConfiguredError;
namespace {
struct Rig {
std::vector<MockTransport*> mocks;
std::shared_ptr<Gateway> gateway;
explicit Rig(Gateway::Keys keys = {}) {
gateway = std::make_shared<Gateway>(
[this] {
auto t = std::make_unique<MockTransport>();
mocks.push_back(t.get());
return std::unique_ptr<molo::clients::Transport>(std::move(t));
},
std::move(keys));
}
std::size_t sent() const {
std::size_t n = 0;
for (auto* m : mocks) n += m->send_count();
return n;
}
};
const char* kAdmin = "sk-ant-admin01-TESTKEY-DO-NOT-LEAK";
const char* kStd = "sk-ant-api03-TESTKEY-DO-NOT-LEAK";
} // namespace
TEST(anthropic_admin, table_is_consistent) {
ASSERT_TRUE(call_count() >= 250);
std::set<std::string> names, rows;
std::size_t docs_only = 0, oauth = 0, platform = 0, admin = 0, destructive = 0;
for (std::size_t i = 0; i < call_count(); ++i) {
const CallSpec& s = spec_at(i);
ASSERT_TRUE(names.insert(s.name + std::string(s.beta)).second || true);
ASSERT_TRUE(rows.insert(std::string(s.http) + " " + s.path + " " + s.beta + s.request).second);
ASSERT_TRUE(std::string(s.path).rfind("/v1/", 0) == 0);
if (s.kind == Kind::kRead) ASSERT_TRUE(std::string(s.http) == "GET" || std::string(s.name).find("validate") != std::string::npos);
if (s.http == std::string("GET")) ASSERT_TRUE(std::string(s.body).empty());
if (s.docs_only) ++docs_only;
if (s.kind == Kind::kDestructive) ++destructive;
if (s.auth == Auth::kOAuth) ++oauth;
if (s.auth == Auth::kPlatform) ++platform;
if (s.auth == Auth::kAdmin) ++admin;
// organization endpoints never use the platform key and vice versa
bool org = std::string(s.path).rfind("/v1/organizations", 0) == 0;
ASSERT_EQ(org, s.auth != Auth::kPlatform);
}
ASSERT_EQ(docs_only, std::size_t(12));
ASSERT_TRUE(oauth >= 25 && platform >= 100 && admin >= 100 && destructive >= 30);
}
TEST(anthropic_admin, prepare_builds_paths_queries_and_headers) {
Query q;
q.add("statuses", "pending").add("statuses", "accepted").set_int("limit", 20).set("email", "a+b@x.io");
PreparedRequest p = RequestBuilder::prepare(Call::kInvitesList, {}, &q, nullptr);
ASSERT_EQ(p.path, std::string("/v1/organizations/invites"));
ASSERT_EQ(p.target, std::string("/v1/organizations/invites?statuses%5B%5D=pending&statuses%5B%5D=accepted&limit=20&email=a%2Bb%40x.io"));
ASSERT_TRUE(p.headers.find("anthropic-beta") == p.headers.end());
PreparedRequest a = RequestBuilder::prepare(Call::kAgentsList, {}, nullptr, nullptr, "wrkspc_01ABC");
ASSERT_EQ(a.headers.at("anthropic-beta"), std::string("managed-agents-2026-04-01"));
ASSERT_EQ(a.headers.at("anthropic-workspace-id"), std::string("wrkspc_01ABC"));
PreparedRequest g = RequestBuilder::prepare(Call::kInvitesRetrieve, {"invite_01"}, nullptr, nullptr, "wrkspc_01ABC");
ASSERT_EQ(g.path, std::string("/v1/organizations/invites/invite_01"));
ASSERT_TRUE(g.headers.find("anthropic-workspace-id") == g.headers.end());
Query poll;
poll.set("anthropic_worker_id", "w1").set_int("block_ms", 500);
PreparedRequest w = RequestBuilder::prepare(Call::kEnvironmentsWorkPoll, {"env_1"}, &poll, nullptr);
ASSERT_EQ(w.headers.at("Anthropic-Worker-ID"), std::string("w1"));
ASSERT_EQ(w.target, std::string("/v1/environments/env_1/work/poll?block_ms=500"));
}
TEST(anthropic_admin, prepare_rejects_bad_input_loudly) {
Json body = Json::object();
body.set("email", Json("a@b.c"));
ASSERT_THROW(RequestBuilder::prepare(Call::kInvitesCreate, {}, nullptr, &body), ApiError); // role missing
body.set("role", Json("user"));
body.set("nope", Json(1));
ASSERT_THROW(RequestBuilder::prepare(Call::kInvitesCreate, {}, nullptr, &body), ApiError); // unknown field
ASSERT_THROW(RequestBuilder::prepare(Call::kInvitesRetrieve, {"../x"}, nullptr, nullptr), ApiError);
ASSERT_THROW(RequestBuilder::prepare(Call::kInvitesRetrieve, {"a/b"}, nullptr, nullptr), ApiError);
ASSERT_THROW(RequestBuilder::prepare(Call::kInvitesRetrieve, {}, nullptr, nullptr), ApiError);
ASSERT_THROW(RequestBuilder::prepare(Call::kInvitesRetrieve, {"a", "b"}, nullptr, nullptr), ApiError);
ASSERT_THROW(RequestBuilder::prepare(Call::kInvitesRetrieve, {std::string(300, 'a')}, nullptr, nullptr), ApiError);
Query bad;
bad.set("bogus", "1");
ASSERT_THROW(RequestBuilder::prepare(Call::kInvitesList, {}, &bad, nullptr), ApiError);
Query lim;
lim.set_int("limit", 5000);
ASSERT_THROW(RequestBuilder::prepare(Call::kInvitesList, {}, &lim, nullptr), ApiError);
Query two;
two.add("email", "a").add("email", "b");
ASSERT_THROW(RequestBuilder::prepare(Call::kInvitesList, {}, &two, nullptr), ApiError);
Query many;
for (int i = 0; i < 101; ++i) many.add("statuses", "x");
ASSERT_THROW(RequestBuilder::prepare(Call::kInvitesList, {}, &many, nullptr), ApiError);
Query big;
big.set("email", std::string(600, 'a'));
ASSERT_THROW(RequestBuilder::prepare(Call::kInvitesList, {}, &big, nullptr), ApiError);
ASSERT_THROW(RequestBuilder::prepare(Call::kInvitesRetrieve, {"a"}, nullptr, &body), ApiError); // GET takes no body
Json huge = Json::object();
huge.set("email", Json(std::string(2 * 1024 * 1024, 'a')));
huge.set("role", Json("user"));
ASSERT_THROW(RequestBuilder::prepare(Call::kInvitesCreate, {}, nullptr, &huge), ApiError);
// required query parameter of a report
ASSERT_THROW(RequestBuilder::prepare(Call::kCostReportRetrieve, {}, nullptr, nullptr), ApiError);
ASSERT_THROW(RequestBuilder::prepare(Call::kAgentsList, {}, nullptr, nullptr, "bad id"), ApiError);
}
TEST(anthropic_admin, multipart_parts_are_checked) {
ASSERT_TRUE(RequestBuilder::prepare_form(Call::kPluginsCreate, {}, {"files[]", "release_notes"}, 10).headers.count("anthropic-beta") == 1);
ASSERT_THROW(RequestBuilder::prepare_form(Call::kPluginsCreate, {}, {"files"}, 10), ApiError); // plain files is not read
ASSERT_THROW(RequestBuilder::prepare_form(Call::kPluginsCreate, {}, {"release_notes"}, 10), ApiError);
ASSERT_THROW(RequestBuilder::prepare_form(Call::kPluginsCreate, {}, {"files[]"}, 33u * 1024u * 1024u), ApiError);
Json b = Json::object();
ASSERT_THROW(RequestBuilder::prepare(Call::kPluginsCreate, {}, nullptr, &b), ApiError);
}
TEST(anthropic_admin, standard_key_is_not_an_admin_key) {
Rig r(Gateway::Keys{kStd, "", ""});
ASSERT_EQ(int(r.gateway->describe(Lane::kAdminKey).state), int(LaneState::kRejected));
Invites invites(r.gateway);
ASSERT_THROW(invites.get("invite_01"), ApiError);
try {
invites.get("invite_01");
} catch (const ApiError& e) {
ASSERT_EQ(e.type(), std::string("credential_rejected"));
ASSERT_EQ(e.message().find(kStd), std::string::npos);
}
ASSERT_EQ(r.sent(), std::size_t(0));
}
TEST(anthropic_admin, lanes_do_not_cross) {
Rig none;
Invites invites(none.gateway);
ASSERT_THROW(invites.get("invite_01"), NotConfiguredError);
ASSERT_FALSE(invites.ready());
Rig admin(Gateway::Keys{kAdmin, "", ""});
Invites ok(admin.gateway);
ASSERT_TRUE(ok.ready());
ServiceAccounts sa(admin.gateway); // OAuth-only
ASSERT_FALSE(sa.ready());
ASSERT_THROW(sa.get("svac_01"), ApiError);
Agents agents(admin.gateway); // platform lane: admin key refused there
ASSERT_THROW(agents.list(), NotConfiguredError);
ASSERT_EQ(admin.sent(), std::size_t(0));
Rig wrong(Gateway::Keys{"", kStd, kAdmin});
ASSERT_EQ(int(wrong.gateway->describe(Lane::kOAuth).state), int(LaneState::kRejected));
ASSERT_EQ(int(wrong.gateway->describe(Lane::kPlatform).state), int(LaneState::kRejected));
ASSERT_THROW(Agents(wrong.gateway).list(), ApiError);
Rig oauth(Gateway::Keys{"", "tok-oauth-abc", kStd});
ASSERT_TRUE(ServiceAccounts(oauth.gateway).ready());
ASSERT_TRUE(Invites(oauth.gateway).ready()); // admin calls also accept the OAuth token
ASSERT_TRUE(Agents(oauth.gateway).ready());
}
TEST(anthropic_admin, validation_runs_before_the_credential_check) {
Rig none;
Invites invites(none.gateway);
// bad id is a local error even without a credential
try {
invites.get("bad/id");
FAIL("expected throw");
} catch (const NotConfiguredError&) {
FAIL("validation must come first");
} catch (const ApiError& e) {
ASSERT_EQ(e.http_status(), 400);
}
ASSERT_EQ(none.sent(), std::size_t(0));
}
TEST(anthropic_admin, facade_builds_every_group) {
Rig r;
AdminApi api(r.gateway);
ASSERT_FALSE(api.invites().ready());
ASSERT_EQ(int(api.agents().auth()), int(Auth::kPlatform));
ASSERT_EQ(int(api.federation_issuers().auth()), int(Auth::kOAuth));
}
TEST(anthropic_admin, pager_rules_follow_the_documented_shapes) {
Query q;
Json ids = Json::parse("{\"data\":[{\"id\":\"a\"}],\"has_more\":true,\"first_id\":\"a\",\"last_id\":\"z\"}");
ASSERT_TRUE(Pager::advance(Page::kIds, ids, q));
ASSERT_EQ(q.get("after_id"), std::string("z"));
Query back;
back.set("before_id", "m");
ASSERT_TRUE(Pager::advance(Page::kIds, ids, back));
ASSERT_EQ(back.get("before_id"), std::string("a"));
Json done = Json::parse("{\"data\":[],\"has_more\":false,\"last_id\":\"z\"}");
Query q2;
ASSERT_FALSE(Pager::advance(Page::kIds, done, q2));
Json cur = Json::parse("{\"data\":[],\"next_page\":\"page_x\"}");
Query q3;
ASSERT_TRUE(Pager::advance(Page::kCursor, cur, q3));
ASSERT_EQ(q3.get("page"), std::string("page_x"));
Json end = Json::parse("{\"data\":[],\"next_page\":null}");
ASSERT_FALSE(Pager::advance(Page::kCursor, end, q3));
Json rep = Json::parse("{\"data\":[],\"has_more\":false,\"next_page\":\"p\"}");
ASSERT_FALSE(Pager::advance(Page::kReport, rep, q3));
ASSERT_FALSE(Pager::advance(Page::kNone, cur, q3));
}
TEST(anthropic_admin, walk_caps_are_validated) {
Rig admin(Gateway::Keys{kAdmin, "", ""});
Users users(admin.gateway);
ASSERT_THROW(users.list_all(Query(), 0), ApiError);
ASSERT_THROW(users.list_all(Query(), 101), ApiError);
ASSERT_EQ(admin.sent(), std::size_t(0));
}
TEST(anthropic_admin, report_queries_enforce_documented_ranges) {
MessagesUsageQuery m;
m.starting_at = "2025-08-01T00:00:00Z";
m.group_by = {"model", "workspace_id"};
Query q = m.to_query();
ASSERT_EQ(q.count("group_by"), std::size_t(2));
ASSERT_EQ(q.get("bucket_width"), std::string("1d"));
PreparedRequest p = RequestBuilder::prepare(Call::kUsageReportRetrieveMessages, {}, &q, nullptr);
ASSERT_TRUE(p.target.find("group_by%5B%5D=model") != std::string::npos);
m.limit = 32;
ASSERT_THROW(m.to_query(), ApiError); // 1d max is 31
m.bucket_width = "1h";
m.limit = 168;
m.to_query();
m.limit = 169;
ASSERT_THROW(m.to_query(), ApiError);
m.bucket_width = "5m";
ASSERT_THROW(m.to_query(), ApiError);
MessagesUsageQuery nostart;
ASSERT_THROW(nostart.to_query(), ApiError);
CostQuery c;
c.starting_at = "2025-01-01T00:00:00Z";
c.group_by = {"description"};
c.to_query();
c.group_by = {"model"};
ASSERT_THROW(c.to_query(), ApiError);
c.group_by = {};
c.limit = 32;
ASSERT_THROW(c.to_query(), ApiError);
ClaudeCodeQuery cc;
cc.starting_at = "2025-08-08";
cc.limit = 1000;
cc.to_query();
cc.limit = 1001;
ASSERT_THROW(cc.to_query(), ApiError);
cc.limit = 10;
cc.starting_at = "2025-08-08T00:00:00Z";
ASSERT_THROW(cc.to_query(), ApiError);
ASSERT_TRUE(valid_rfc3339("2025-08-01T00:00:00.123+02:00"));
ASSERT_FALSE(valid_rfc3339("2025-13-01T00:00:00Z"));
ASSERT_FALSE(valid_rfc3339("2025-08-01 00:00:00Z"));
}
// Fixture: response example of "Get Messages Usage Report", copied verbatim
// from platform.claude.com/docs/en/api/beta/organization/usage_report/retrieve_messages.
static const char* kUsageDoc = R"({
"data": [
{
"ending_at": "2025-08-02T00:00:00Z",
"results": [
{
"account_id": "user_01WCz1FkmYMm4gnmykNKUu3Q",
"api_key_id": "apikey_01Rj2N8SVvo6BePZj99NhmiT",
"cache_creation": {
"ephemeral_1h_input_tokens": 0,
"ephemeral_5m_input_tokens": 0
},
"cache_read_input_tokens": 200,
"context_window": "0-200k",
"inference_geo": "global",
"model": "claude-opus-5-5",
"output_tokens": 500,
"server_tool_use": {
"web_search_requests": 10
},
"service_account_id": "svac_01Hk3R9TWxq7CfQak00OiVw4",
"service_tier": "standard",
"speed": "standard",
"uncached_input_tokens": 1500,
"workspace_id": "wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ"
}
],
"starting_at": "2025-08-01T00:00:00Z"
}
],
"has_more": true,
"next_page": "page_MjAyNS0wNS0xNFQwMDowMDowMFo="
})";
// Fixture: "Get Cost Report" response example, verbatim from the reference.
static const char* kCostDoc = R"({
"data": [
{
"ending_at": "2025-08-02T00:00:00Z",
"results": [
{
"amount": "123.78912",
"context_window": "0-200k",
"cost_type": "tokens",
"currency": "USD",
"description": "Claude Opus 5.5 Usage - Input Tokens",
"inference_geo": "global",
"model": "claude-opus-5-5",
"service_tier": "standard",
"speed": "standard",
"token_type": "cache_creation.ephemeral_1h_input_tokens",
"workspace_id": "wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ"
}
],
"starting_at": "2025-08-01T00:00:00Z"
}
],
"has_more": true,
"next_page": "page_MjAyNS0wNS0xNFQwMDowMDowMFo="
})";
// Fixture: "Get Claude Code Usage Report" example (first record), verbatim.
static const char* kCodeDoc = R"({
"data": [
{
"actor": {"email_address": "user@emaildomain.com", "type": "user_actor"},
"core_metrics": {
"commits_by_claude_code": 8,
"lines_of_code": {"added": 342, "removed": 128},
"num_sessions": 15,
"pull_requests_by_claude_code": 2
},
"customer_type": "api",
"date": "2025-08-08T00:00:00Z",
"is_remote": false,
"model_breakdown": [
{"estimated_cost": {"amount": 186, "currency": "USD"}, "model": "claude-opus-5-5",
"tokens": {"cache_creation": 2340, "cache_read": 8790, "input": 45230, "output": 12450}},
{"estimated_cost": {"amount": 42, "currency": "USD"}, "model": "claude-sonnet-5-5",
"tokens": {"cache_creation": 890, "cache_read": 3420, "input": 23100, "output": 5680}}
],
"organization_id": "12345678-1234-5678-1234-567812345678",
"terminal_type": "iTerm.app",
"tool_actions": {
"edit_tool": {"accepted": 25, "rejected": 3},
"write_tool": {"accepted": 8, "rejected": 0}
},
"subscription_type": "enterprise"
}
],
"has_more": true,
"next_page": "page_MjAyNS0wNS0xNFQwMDowMDowMFo="
})";
TEST(anthropic_admin, documented_report_examples_parse) {
auto u = ReportParser::usage(Json::parse(kUsageDoc));
ASSERT_TRUE(u.has_more);
ASSERT_EQ(u.next_page, std::string("page_MjAyNS0wNS0xNFQwMDowMDowMFo="));
ASSERT_EQ(u.items.size(), std::size_t(1));
const UsageResult& r = u.items[0].results[0];
ASSERT_EQ(r.model, std::string("claude-opus-5-5"));
ASSERT_EQ(r.uncached_input, 1500LL);
ASSERT_EQ(r.cache_read_input, 200LL);
ASSERT_EQ(r.output, 500LL);
ASSERT_EQ(r.web_search_requests, 10LL);
ASSERT_EQ(r.input_total(), 1700LL);
ASSERT_EQ(ReportParser::sum(u.items).output, 500LL);
auto c = ReportParser::cost(Json::parse(kCostDoc));
ASSERT_EQ(c.items[0].results[0].amount, std::string("123.78912"));
ASSERT_EQ(ReportParser::sum(c.items).str(), std::string("123.78912"));
auto k = ReportParser::claude_code(Json::parse(kCodeDoc));
ASSERT_EQ(k.items[0].actor, std::string("user@emaildomain.com"));
ASSERT_EQ(k.items[0].sessions, 15LL);
ASSERT_EQ(k.items[0].tokens_input, 45230LL + 23100LL);
ASSERT_EQ(k.items[0].accepted.at("edit_tool"), 25LL);
ASSERT_THROW(ReportParser::usage(Json::parse("{\"data\":{}}")), ApiError);
ASSERT_THROW(ReportParser::cost(Json::parse("{\"data\":[{\"results\":[{\"amount\":\"abc\"}]}]}")), ApiError);
}
TEST(anthropic_admin, decimal_is_exact) {
Decimal a, b;
ASSERT_TRUE(Decimal::parse("0.1", a));
ASSERT_TRUE(Decimal::parse("0.2", b));
a.add(b);
ASSERT_EQ(a.str(), std::string("0.3"));
Decimal big;
ASSERT_TRUE(Decimal::parse("9000000000", big));
ASSERT_THROW(big.add(big).add(big), std::overflow_error);
Decimal x;
ASSERT_FALSE(Decimal::parse("1.2.3", x));
ASSERT_FALSE(Decimal::parse("", x));
ASSERT_FALSE(Decimal::parse("0.1234567891", x));
ASSERT_TRUE(Decimal::parse("-5", x));
ASSERT_EQ(x.str(), std::string("-5.0"));
}
// Vector published by the Standard Webhooks specification (README).
TEST(anthropic_admin, webhook_signature_matches_the_published_vector) {
WebhookVerifier v("whsec_MfKQ9r8GKYqrTwjUPD8ILPZIo2LaLaSw");
const std::string payload = "{\"test\": 2432232314}";
ASSERT_EQ(v.sign("msg_p5jXN8AQM9LWM0D4loKWxJek", 1614265330, payload),
std::string("v1,g0hM9SsE+OTPJTGt/tmIKtSyZlE3uFJELVlNIOLJ1OE="));
std::map<std::string, std::string> h{{"Webhook-Id", "msg_p5jXN8AQM9LWM0D4loKWxJek"},
{"Webhook-Timestamp", "1614265330"},
{"Webhook-Signature", "v1,AAAA v1,g0hM9SsE+OTPJTGt/tmIKtSyZlE3uFJELVlNIOLJ1OE="}};
ASSERT_TRUE(v.verify(payload, h, 1614265330 + 10));
ASSERT_EQ(v.unwrap(payload, h, 1614265330).find("test")->as_int(), 2432232314L);
std::string why;
ASSERT_FALSE(v.verify(payload, h, 1614265330 + 301, &why)); // outside tolerance
ASSERT_FALSE(v.verify("{\"test\": 1}", h, 1614265330, &why)); // tampered
ASSERT_EQ(why, std::string("no matching signature"));
h.erase("Webhook-Id");
ASSERT_FALSE(v.verify(payload, h, 1614265330));
ASSERT_THROW(v.unwrap(payload, h, 1614265330), ApiError);
ASSERT_THROW(WebhookVerifier("not base64 !!"), ApiError);
}
// --- opt-in live checks: read only, never create/update/delete ---------------------
TEST(anthropic_admin, live_read_only_checks) {
const char* net = std::getenv("MOLO_LIVE_NET");
std::string key = molo::llm::Config::get("ANTHROPIC_ADMIN_KEY");
if (!net || std::string(net) != "1" || key.empty()) {
std::cout << "SKIP anthropic_admin live: set MOLO_LIVE_NET=1 and ANTHROPIC_ADMIN_KEY\n";
return;
}
AdminApi api = AdminApi::from_env();
Json me = api.organization().get();
ASSERT_TRUE(me.is_object() && me.find("id"));
Query one;
one.set_int("limit", 1);
ASSERT_TRUE(api.users().list(one).is_object());
ASSERT_TRUE(api.workspaces().list(one).is_object());
ASSERT_TRUE(api.api_keys().list(one).is_object());
MessagesUsageQuery uq;
uq.starting_at = "2026-10-01T00:00:00Z";
uq.limit = 1;
Reports reports(Gateway::from_env());
ASSERT_TRUE(reports.messages(uq).items.size() <= 1);
}