diff --git a/example/app/ai/AnthropicAdminDemo.cpp b/example/app/ai/AnthropicAdminDemo.cpp
index 4025f70..3c83791 100644
--- a/example/app/ai/AnthropicAdminDemo.cpp
+++ b/example/app/ai/AnthropicAdminDemo.cpp
@@ -1,13 +1,349 @@
#include "../AiDemos.hpp"
#include "../../fw/Router.hpp"
+#include "../../fw/Templates.hpp"
+#include "anthropic/admin/calls.h"
+#include "anthropic/admin/gateway.h"
+#include "anthropic/admin/reports.h"
+#include "anthropic/admin/request.h"
+#include "anthropic/admin/webhook.h"
+#include "llm/error.h"
namespace molo::example::app {
-// Anthropic Claude: admin API (orgs, workspaces, keys, usage, cost) and managed agents. Stub: the module agent fills this in.
+// Anthropic admin: Admin API (organization, users, invites, workspaces, keys,
+// service accounts, federation, RBAC, spend limits, plugins, webhooks, Claude
+// Tag), usage and cost reports, and the Managed Agents surface, over the real
+// src/anthropic/admin package. GET routes need no credential. Every route that
+// calls Anthropic is a POST: 503 not_configured without a credential, 422 on
+// bad input, 401 credential_rejected for a key of the wrong kind. Anything that
+// is not a read is a dry run unless the body says "confirm":true.
+
+namespace {
+
+namespace adm = anthropic::admin;
+using Json = clients::body::Json;
+
+constexpr std::size_t kMaxBody = 256 * 1024;
+
+const char kPage[] = R"ADMIN({% extends "base.html" %}
+{% block content %}
+
Anthropic admin
+Organization, workspaces, keys, usage and cost reports, and Managed
+Agents. Reads run as is; every write or delete is a dry run until you tick confirm.
+Checking credentials...
+
+
+
+{% endblock %}
+)ADMIN";
+
+fw::Response json_out(const Json& j, int status = 200) {
+ fw::Response res = fw::JsonResponse(j.dump(), status);
+ res.headers.set("Cache-Control", "no-store");
+ return res;
+}
+
+[[noreturn]] void bad(const std::string& why) { throw fw::HttpError(422, "validation_error", why); }
+
+[[noreturn]] void rethrow(const llm::ApiError& e) {
+ if (e.type() == "NOT_CONFIGURED") throw fw::HttpError(503, "not_configured", e.message());
+ if (e.type() == "credential_rejected") throw fw::HttpError(e.http_status() == 403 ? 403 : 401, "credential_rejected", e.message());
+ if (e.type() == "INVALID_ARGUMENT") bad(e.message());
+ throw fw::HttpError(502, "anthropic_error", std::to_string(e.http_status()) + " " + e.type() + ": " + e.message());
+}
+
+template
+auto guarded(F&& f) -> decltype(f()) {
+ try {
+ return f();
+ } catch (const llm::ApiError& e) {
+ rethrow(e);
+ }
+}
+
+Json parse_body(const fw::Request& req) {
+ if (req.body.size() > kMaxBody) throw fw::HttpError(413, "payload_too_large", "body too large");
+ if (req.body.empty()) return Json::object();
+ try {
+ Json j = Json::parse(req.body);
+ if (!j.is_object()) bad("body must be a JSON object");
+ return j;
+ } catch (const clients::body::JsonError&) {
+ bad("body is not valid JSON");
+ }
+}
+
+std::string text(const Json& body, const char* key) {
+ const Json* v = body.find(key);
+ if (!v || v->is_null()) return "";
+ if (!v->is_string()) bad(std::string(key) + " must be a string");
+ return v->as_string();
+}
+
+bool flag(const Json& body, const char* key) {
+ const Json* v = body.find(key);
+ if (!v || v->is_null()) return false;
+ if (!v->is_bool()) bad(std::string(key) + " must be true or false");
+ return v->as_bool();
+}
+
+std::vector strings(const Json& body, const char* key) {
+ std::vector out;
+ const Json* v = body.find(key);
+ if (!v || v->is_null()) return out;
+ if (!v->is_array()) bad(std::string(key) + " must be an array of strings");
+ for (const Json& s : v->as_array()) {
+ if (!s.is_string()) bad(std::string(key) + " must be an array of strings");
+ out.push_back(s.as_string());
+ }
+ return out;
+}
+
+const char* kind_name(adm::Kind k) {
+ return k == adm::Kind::kRead ? "read" : k == adm::Kind::kWrite ? "write" : "destructive";
+}
+const char* auth_name(adm::Auth a) {
+ return a == adm::Auth::kAdmin ? "admin_key_or_oauth" : a == adm::Auth::kOAuth ? "oauth_token" : "api_key";
+}
+
+// Looks a call up by its table name; "name" and "name+beta" forms share names, the
+// first row wins (the beta form carries a "beta" suffix in the name).
+const adm::CallSpec* find_call(const std::string& name) {
+ for (std::size_t i = 0; i < adm::call_count(); ++i)
+ if (name == adm::spec_at(i).name) return &adm::spec_at(i);
+ return nullptr;
+}
+
+class AdminRoutes {
+ public:
+ explicit AdminRoutes(std::shared_ptr gateway) : gateway_(std::move(gateway)) {}
+
+ Json status() const {
+ Json o = Json::object();
+ Json lanes = Json::object();
+ for (const adm::LaneInfo& l : gateway_->lanes()) {
+ Json s = Json::object();
+ s.set("env", Json(l.env));
+ s.set("state", Json(l.state == adm::LaneState::kReady ? "ready" : l.state == adm::LaneState::kMissing ? "missing" : "rejected"));
+ if (!l.reason.empty()) s.set("reason", Json(l.reason));
+ lanes.set(adm::KeyRules::name_of(l.lane), s);
+ }
+ o.set("lanes", lanes);
+ o.set("configured", Json(gateway_->ready(adm::Auth::kAdmin)));
+ o.set("calls", Json(static_cast(adm::call_count())));
+ o.set("api_version", Json(adm::Gateway::kApiVersion));
+ return o;
+ }
+
+ Json calls() const {
+ Json arr = Json::array();
+ for (std::size_t i = 0; i < adm::call_count(); ++i) {
+ const adm::CallSpec& s = adm::spec_at(i);
+ Json c = Json::object();
+ c.set("name", Json(s.name));
+ c.set("http", Json(s.http));
+ c.set("path", Json(s.path));
+ c.set("kind", Json(kind_name(s.kind)));
+ c.set("credential", Json(auth_name(s.auth)));
+ c.set("beta", Json(s.beta));
+ arr.push(c);
+ }
+ Json o = Json::object();
+ o.set("calls", arr);
+ return o;
+ }
+
+ // Generic table-driven call: validate, dry-run non-reads, then send.
+ fw::Response call(const fw::Request& req) const {
+ Json b = parse_body(req);
+ std::string name = text(b, "call");
+ if (name.empty()) bad("call is required");
+ const adm::CallSpec* spec = find_call(name);
+ if (!spec) bad("unknown call " + name);
+ if (spec->wire != adm::Wire::kJson)
+ bad(name + " is a " + (spec->wire == adm::Wire::kSse ? "stream" : spec->wire == adm::Wire::kRaw ? "download" : "multipart upload") + " call and is not available here");
+ adm::Query query;
+ if (const Json* q = b.find("query")) {
+ if (!q->is_object()) bad("query must be a JSON object");
+ for (const auto& [k, v] : q->as_object()) {
+ if (v.is_array()) {
+ for (const Json& item : v.as_array()) {
+ if (!item.is_string() && !item.is_number()) bad(k + " values must be strings or numbers");
+ query.add(k, item.is_string() ? item.as_string() : std::to_string(item.as_int()));
+ }
+ } else if (v.is_string()) {
+ query.set(k, v.as_string());
+ } else if (v.is_number()) {
+ query.set_int(k, v.as_int());
+ } else if (v.is_bool()) {
+ query.set_bool(k, v.as_bool());
+ } else {
+ bad(k + " must be a string, number, boolean or array");
+ }
+ }
+ }
+ const Json* body = b.find("body");
+ if (body && !body->is_null() && !body->is_object()) bad("body must be a JSON object");
+ bool has_body = body && body->is_object() && !body->as_object().empty();
+ bool confirm = flag(b, "confirm");
+ adm::PreparedRequest p = guarded([&] {
+ return adm::RequestBuilder::prepare(find_enum(spec), strings(b, "ids"), &query,
+ (has_body || adm::RequestBuilder::names(spec->body).size() ? body : nullptr),
+ gateway_->workspace_id());
+ });
+ if (spec->kind != adm::Kind::kRead && !confirm) {
+ Json o = Json::object();
+ o.set("dry_run", Json(true));
+ o.set("would_send", Json(std::string(spec->http) + " " + p.target));
+ o.set("kind", Json(kind_name(spec->kind)));
+ o.set("hint", Json("send confirm:true to run it"));
+ return json_out(o);
+ }
+ return guarded([&] {
+ auto client = gateway_->client_for(spec->auth);
+ return json_out(client->request(p.method, p.target, p.body ? &*p.body : nullptr, p.headers));
+ });
+ }
+
+ fw::Response organization(const fw::Request&) const {
+ return guarded([&] {
+ adm::PreparedRequest p = adm::RequestBuilder::prepare(adm::Call::kOrganizationRetrieve, {}, nullptr, nullptr);
+ return json_out(gateway_->client_for(adm::Auth::kAdmin)->request(p.method, p.target, nullptr, p.headers));
+ });
+ }
+
+ fw::Response report(const fw::Request& req, int which) const {
+ Json b = parse_body(req);
+ std::string start = text(b, "starting_at");
+ std::string ending = text(b, "ending_at");
+ std::string page = text(b, "page");
+ long limit = 0;
+ if (const Json* l = b.find("limit")) {
+ if (!l->is_number()) bad("limit must be a number");
+ limit = l->as_int();
+ }
+ std::vector group = strings(b, "group_by");
+ return guarded([&] {
+ adm::Query q;
+ adm::Call c;
+ if (which == 0) {
+ adm::MessagesUsageQuery m;
+ m.starting_at = start;
+ m.ending_at = ending;
+ m.limit = limit;
+ m.page = page;
+ m.group_by = group;
+ std::string w = text(b, "bucket_width");
+ if (!w.empty()) m.bucket_width = w;
+ q = m.to_query();
+ c = adm::Call::kUsageReportRetrieveMessages;
+ } else if (which == 1) {
+ adm::CostQuery m;
+ m.starting_at = start;
+ m.ending_at = ending;
+ m.limit = limit;
+ m.page = page;
+ m.group_by = group;
+ q = m.to_query();
+ c = adm::Call::kCostReportRetrieve;
+ } else {
+ adm::ClaudeCodeQuery m;
+ m.starting_at = start;
+ m.limit = limit;
+ m.page = page;
+ q = m.to_query();
+ c = adm::Call::kUsageReportRetrieveClaudeCode;
+ }
+ adm::PreparedRequest p = adm::RequestBuilder::prepare(c, {}, &q, nullptr);
+ return json_out(gateway_->client_for(adm::Auth::kAdmin)->request(p.method, p.target, nullptr, p.headers));
+ });
+ }
+
+ // Local: verifies a webhook signature; no credential involved.
+ fw::Response verify_webhook(const fw::Request& req) const {
+ Json b = parse_body(req);
+ std::string key = text(b, "signing_key"), payload = text(b, "payload");
+ if (key.empty()) bad("signing_key is required");
+ if (payload.empty()) bad("payload is required");
+ std::map h{{"webhook-id", text(b, "webhook_id")},
+ {"webhook-timestamp", text(b, "webhook_timestamp")},
+ {"webhook-signature", text(b, "webhook_signature")}};
+ return guarded([&] {
+ adm::WebhookVerifier v(key);
+ std::string why;
+ bool ok = v.verify(payload, h, static_cast(std::time(nullptr)), &why);
+ Json o = Json::object();
+ o.set("valid", Json(ok));
+ if (!ok) o.set("reason", Json(why));
+ return json_out(o);
+ });
+ }
+
+ private:
+ static adm::Call find_enum(const adm::CallSpec* spec) { return spec->call; }
+ std::shared_ptr gateway_;
+};
+
+} // namespace
+
void register_ai_anthropicadmin_demo(fw::Router& router, Services& services) {
- (void)router;
- (void)services;
+ auto gateway = adm::Gateway::from_env();
+ auto routes = std::make_shared(gateway);
+ fw::Environment* env = services.templates.get();
+ services.templates->add_template("ai_anthropic_admin.html", kPage);
+ services.add_feature("ai-anthropic-admin", "/ai/anthropic/admin");
+
+ router.get("/ai/anthropic/admin", "ai-anthropic-admin-page", [env](fw::Request) {
+ fw::TemplateCtx ctx;
+ ctx["title"] = std::string("Anthropic admin");
+ return fw::Response(200, env->render("ai_anthropic_admin.html", ctx), "text/html; charset=utf-8");
+ });
+ router.get("/ai/anthropic/admin/status", "ai-anthropic-admin-status",
+ [routes](fw::Request) { return json_out(routes->status()); });
+ router.get("/ai/anthropic/admin/calls", "ai-anthropic-admin-calls",
+ [routes](fw::Request) { return json_out(routes->calls()); });
+ router.post("/ai/anthropic/admin/call", "ai-anthropic-admin-call",
+ [routes](fw::Request req) { return routes->call(req); });
+ router.post("/ai/anthropic/admin/organization", "ai-anthropic-admin-organization",
+ [routes](fw::Request req) { return routes->organization(req); });
+ router.post("/ai/anthropic/admin/usage", "ai-anthropic-admin-usage",
+ [routes](fw::Request req) { return routes->report(req, 0); });
+ router.post("/ai/anthropic/admin/cost", "ai-anthropic-admin-cost",
+ [routes](fw::Request req) { return routes->report(req, 1); });
+ router.post("/ai/anthropic/admin/claude-code", "ai-anthropic-admin-claude-code",
+ [routes](fw::Request req) { return routes->report(req, 2); });
+ router.post("/ai/anthropic/admin/webhook/verify", "ai-anthropic-admin-webhook-verify",
+ [routes](fw::Request req) { return routes->verify_webhook(req); });
}
} // namespace molo::example::app
diff --git a/example/assets/ai_anthropic_admin.js b/example/assets/ai_anthropic_admin.js
new file mode 100644
index 0000000..c508162
--- /dev/null
+++ b/example/assets/ai_anthropic_admin.js
@@ -0,0 +1,59 @@
+// Anthropic admin page: thin client over /ai/anthropic/admin/* (all limits server side).
+(function () {
+ "use strict";
+ var $ = function (id) { return document.getElementById(id); };
+ var out = $("ad-out"), err = $("ad-error");
+
+ function post(path, body) {
+ err.textContent = "";
+ out.textContent = "...";
+ return fetch(path, {
+ method: "POST",
+ headers: { "Content-Type": "application/json" },
+ body: JSON.stringify(body)
+ }).then(function (res) {
+ return res.text().then(function (t) {
+ var j;
+ try { j = JSON.parse(t); } catch (e) { j = { message: t }; }
+ if (!res.ok) {
+ err.textContent = j.message || ("HTTP " + res.status);
+ out.textContent = "";
+ } else {
+ out.textContent = JSON.stringify(j, null, 2);
+ }
+ });
+ }).catch(function (e) { err.textContent = String(e); out.textContent = ""; });
+ }
+ function json(id) {
+ try { return JSON.parse($(id).value || "{}"); }
+ catch (e) { err.textContent = "Not valid JSON: " + id; return null; }
+ }
+
+ fetch("/ai/anthropic/admin/status").then(function (r) { return r.json(); }).then(function (s) {
+ var l = s.lanes || {};
+ $("ad-config").textContent = "Admin key: " + (l.admin_key || {}).state +
+ ", OAuth token: " + (l.oauth_token || {}).state + ", API key: " + (l.api_key || {}).state +
+ ". " + s.calls + " calls, API version " + s.api_version + ".";
+ });
+ fetch("/ai/anthropic/admin/calls").then(function (r) { return r.json(); }).then(function (d) {
+ var sel = $("ad-call");
+ d.calls.forEach(function (c) {
+ var o = document.createElement("option");
+ o.value = c.name;
+ o.textContent = c.http + " " + c.name + (c.kind === "read" ? "" : " (" + c.kind + ")");
+ sel.appendChild(o);
+ });
+ });
+
+ $("ad-org").onclick = function () { post("/ai/anthropic/admin/organization", {}); };
+ $("ad-run-report").onclick = function () {
+ var group = $("ad-group").value.split(",").map(function (s) { return s.trim(); }).filter(Boolean);
+ post("/ai/anthropic/admin/" + $("ad-report").value, { starting_at: $("ad-start").value.trim(), group_by: group });
+ };
+ $("ad-send").onclick = function () {
+ var q = json("ad-query"), b = json("ad-body");
+ if (!q || !b) return;
+ var ids = $("ad-ids").value.split(",").map(function (s) { return s.trim(); }).filter(Boolean);
+ post("/ai/anthropic/admin/call", { call: $("ad-call").value, ids: ids, query: q, body: b, confirm: $("ad-confirm").checked });
+ };
+})();
diff --git a/src/anthropic/admin/SPEC.md b/src/anthropic/admin/SPEC.md
new file mode 100644
index 0000000..285106d
--- /dev/null
+++ b/src/anthropic/admin/SPEC.md
@@ -0,0 +1,165 @@
+# Anthropic admin and agent platform (`molo::anthropic::admin`)
+
+Status 2026-10-24. Plan: `plans/17-llm-vendor-platforms.md`, package
+"anthropic admin". The Messages, Batches, Files, Models and Skills families
+belong to `src/anthropic/core` and are excluded (see `EXCLUDED` in the checker).
+
+## Scope
+
+255 calls in one table (`calls.cpp`), 243 read from the official Python SDK
+and 12 documented only in the API reference:
+
+| Credential | Calls | Surface |
+|---|---|---|
+| Admin API key or `org:admin` OAuth token (125) | organization info, users, invites, workspaces, workspace members and rate limits, API keys, external keys (CMEK), rate limits, compliance settings, RBAC groups and roles, spend limits, plugins, plugin marketplaces, telemetry destinations, organization webhooks, Claude Tag, Enterprise analytics, usage and cost reports, organization-level MCP tunnel views |
+| `org:admin` OAuth token only (26) | service accounts (and their workspaces), federation issuers and rules, workspace service accounts |
+| Standard API key (104) | Managed Agents: agents (+versions), environments (+work queue), sessions (+events, resources, threads, thread events, SSE streams), deployments, deployment runs, vaults (+credentials), memory stores (+memories, versions), dreams, tunnels (+certificates), user profiles (+action URLs) |
+
+Managed Agents is public REST (`/v1/agents`, `/v1/sessions`, ...), beta header
+`managed-agents-2026-04-01` (other families carry their own beta header,
+column `beta`). It uses the standard workspace key, not the admin key, so the
+package keeps three credential lanes (below).
+
+## Module map (one concern per class)
+
+| File | Class | Concern |
+|---|---|---|
+| `calls.h/.cpp` | `Call`, `CallSpec` | generated table, the only place paths live |
+| `services/*.h/.cpp` | one class per resource group (`Invites`, `Workspaces`, `Agents`, ...) | generated methods, one per row; `list_all` for paged rows |
+| `api.h` | `AdminApi` | facade owning every group |
+| `credentials.h/.cpp` | `KeyRules`, `Lane` | which key may go in which lane |
+| `gateway.h/.cpp` | `Gateway` | three `llm::ApiClient` lanes, lane choice per call, GET SSE |
+| `request.h/.cpp` | `RequestBuilder` | all local validation; builds the exact request without network |
+| `query.h/.cpp` | `Query` | query parameters, arrays as `name[]` |
+| `pager.h/.cpp` | `Pager`, `Walk` | page rules for the four page shapes, capped walks |
+| `resource.h/.cpp` | `Resource : llm::Service` | send, send raw, multipart, stream, walk |
+| `reports.h/.cpp` | `MessagesUsageQuery`, `CostQuery`, `ClaudeCodeQuery`, `ReportParser`, `Decimal`, `Reports` | usage and cost reports |
+| `webhook.h/.cpp` | `WebhookVerifier` | Standard Webhooks signature check |
+| `caps.h` | `Caps` | every ceiling |
+| `tools/check_spec.py` | | verifier and generator |
+
+## Contracts
+
+- Credentials: `ANTHROPIC_ADMIN_KEY` (must start `sk-ant-admin`, header
+ `x-api-key`), `ANTHROPIC_AUTH_TOKEN` (org:admin OAuth token, `Authorization:
+ Bearer`; the only credential for the 26 OAuth-only calls), `ANTHROPIC_API_KEY`
+ (standard key, managed agents). A standard key in the admin lane, an API key
+ in the OAuth lane, an admin key in the platform lane: refused locally with
+ `credential_rejected`, no request leaves. Nothing configured:
+ `NotConfiguredError` (503). Keys are never logged or shown (status shows
+ state only).
+- Local validation comes before the credential check: path ids through
+ `Service::valid_id` (1..256 of `A-Za-z0-9._:-`), unknown and missing body
+ fields and query parameters, `limit` 1..1000, <=100 values per array
+ parameter, <=512 bytes per value, <=8 KiB query, <=1 MiB JSON body, multipart
+ <=32 MiB and <=512 parts, form part names (`files[]`, plain `files` is
+ refused), report ranges per bucket width (1d 31, 1h 168, 1m 1440; cost 31;
+ Claude Code 1000). Errors are `ApiError` 400 `INVALID_ARGUMENT`.
+- Headers: `anthropic-version: 2026-10-21` (pinned), `anthropic-beta` from the
+ row, `anthropic-workspace-id` only where the row accepts it
+ (`Gateway::set_workspace_id`), header parameters (`Anthropic-Worker-ID`).
+- Query arrays use the SDK's `brackets` format: `group_by[]=a&group_by[]=b`.
+- Paging: `Pager` follows `has_more`/`last_id` (ids), `next_page` (cursor and
+ report) and stops when the server says so. `list_all` is capped at
+ `Caps::kMaxPages` (20, hard 100) pages and `kMaxItems` (5000) items and
+ reports `Walk.truncated` with `reason` and the continuing `next_page`.
+- Mutating calls are `Kind::kWrite`, deletes/archives/cancels/stops/redacts/
+ token rotation `Kind::kDestructive`; each is its own explicit method (no
+ default behaviour, marked MUTATES / DESTRUCTIVE in the generated header).
+ Secret-returning calls (`reveal_token`) are marked.
+- Streams (`sessions.events.stream`, `sessions.threads.events.stream`) are GET
+ SSE through `Gateway::stream_get`, at most `Caps::kMaxStreamEvents` events.
+- Webhooks: Standard Webhooks (`webhook-id`, `webhook-timestamp`,
+ `webhook-signature`, `whsec_` key, HMAC-SHA256 via wolfSSL), tolerance 300 s.
+- Reports: `Decimal` is exact fixed point (9 digits); cost `amount` strings are
+ summed without floating point and overflow throws.
+
+## Demo (`example/app/ai/AnthropicAdminDemo.cpp`)
+
+`GET /ai/anthropic/admin` (page), `/status` (lane states, never a key),
+`/calls` (the table). `POST /call` (any non-stream, non-upload row by name:
+validated, dry run for every non-read unless `"confirm":true`), `/organization`,
+`/usage`, `/cost`, `/claude-code`, `/webhook/verify` (local). 503
+`not_configured` without credential, 422 bad input, 401/403 `credential_rejected`.
+
+## Sources
+
+1. Official Python SDK `anthropics/anthropic-sdk-python` commit
+ `202db72c87d7c6eaa72129c67ce67fd343a3a20c` (release 2.3.0, 2026-10-23):
+ `src/anthropic/resources/**` (verb, path, body keys, query keys, header
+ params, beta header, page class, return type) and `types/**/*_params.py`
+ (TypedDict fields). `.stats.yml` says `configured_endpoints: 349` and has no
+ `openapi_spec_url` (also checked: TypeScript, Go, Java, Ruby, C#, PHP): there
+ is no published OpenAPI document, so the SDK source is the machine-readable
+ source. `_client.py` fixes query arrays to `brackets`, `_constants.py` the
+ API version.
+2. API reference pages `platform.claude.com/docs/en/api/**.md` (one per
+ operation; method and path line, path/query/body parameters, credential
+ note "Admin API keys are not accepted").
+3. Guides `manage-claude/admin-api`, `admin-api-keys`, `usage-cost-api`,
+ `claude-tag-api` (credential rules, report semantics, Claude Tag endpoints).
+4. Standard Webhooks specification (signature scheme, published test vector).
+
+## Verified against spec
+
+`python3 -I src/anthropic/admin/tools/check_spec.py` on 2026-10-24: 351 SDK
+operations scanned, 255 table rows (12 docs-only), 253 reference pages checked
+(14 rows are checked against the Claude Tag guide or the SDK alone), 0 failures.
+It fails when a generated file is stale, a row disagrees with the SDK or its
+page (verb, path, every body and query field in both directions, credential
+class), a field is missing from the SDK params module, or an SDK operation is
+neither in the table nor excluded (Messages, Batches, Models, Files, Skills).
+Regenerate with `--emit`. `--sdk-tar` and `--pages-dir` reuse local copies.
+
+## Verified live
+
+Unauthenticated probes, 2026-10-24: see "Probes" at the end of this file.
+No Anthropic key exists in this environment: no authenticated call has been
+made. Opt-in live test (`MOLO_LIVE_NET=1` plus `ANTHROPIC_ADMIN_KEY`): read-only
+organization info, one-item lists of users, workspaces, API keys, one report.
+It prints a loud SKIP otherwise.
+
+## Unverified
+
+- Response shapes beyond the documented report examples (typed parsing exists
+ only for the three reports; everything else is returned as `Json`).
+- Whether an Admin API key is accepted by the 26 OAuth-only calls: the pages
+ say it is not; the package follows the pages.
+- Rows with no reference page: `analytics/usage` and `analytics/cost`
+ (SDK only); Claude Tag (guide only, field names from the SDK).
+- Fields documented but not in the SDK params: none at this commit.
+- Report enum members (`group_by`, `service_tiers`, ...) are not validated
+ locally except cost `group_by`; the server rejects unknown values.
+- `sessions.resources.add` has `type` required in the SDK signature while the
+ migration guide says it is optional; the table follows the SDK.
+- Actual limits enforced by the server for `limit` on non-report lists (the
+ package only caps at 1000).
+
+## Gaps
+
+- Personal and service-account keys not scoped to a workspace are valid Admin
+ API credentials per the docs, but look like standard keys (`sk-ant-api...`)
+ and are refused by design (rule: the standard key is never accepted).
+ Claude Enterprise scoped keys (`sk-ant-api01`) fall under the same rule.
+- No GET streaming in `llm::ApiClient` (foundation gap, `src/llm`): the package
+ has its own `Gateway::stream_get`.
+- Multipart upload goes through `ApiClient::post_multipart`, which parses a JSON
+ reply only; the binary plugin download uses `request_raw`.
+- No typed models for non-report resources; no OAuth token refresh.
+- `ANTHROPIC_AUTH_TOKEN` is the SDK's name for the bearer token; the plan's
+ key list names only `ANTHROPIC_ADMIN_KEY`.
+
+## Probes (unauthenticated, 2026-10-24, header `anthropic-version: 2026-10-21`)
+
+Host `api.anthropic.com` resolves, TLS works. Every documented path below
+answers 401 (not 404) with the documented envelope
+`{"type":"error","error":{"type":"authentication_error","message":...},"request_id":...}`;
+an invented route answers 404 `not_found_error`.
+
+| Path | Status |
+|---|---|
+| `/v1/organizations/{me,users,workspaces,api_keys,service_accounts,cost_report,tunnels}` | 401 `x-api-key header is required` |
+| `/v1/organizations/usage_report/{messages,claude_code}` | 401 (the two docs-only report paths exist) |
+| `/v1/agents`, `/v1/sessions`, `/v1/vaults` | 401 `Authentication failed` |
+| `/v1/environments` | 401 `x-api-key header is required` |
+| `/v1/nonexistent_route` | 404 `not_found_error` |
diff --git a/src/anthropic/admin/api.h b/src/anthropic/admin/api.h
new file mode 100644
index 0000000..9e6ceab
--- /dev/null
+++ b/src/anthropic/admin/api.h
@@ -0,0 +1,265 @@
+// GENERATED by src/anthropic/admin/tools/check_spec.py --emit. Do not edit by hand:
+// the table is verified against the SDK source and the reference pages.
+#pragma once
+
+// AdminApi: every resource group of the package behind one object. Build it
+// from the environment (ANTHROPIC_ADMIN_KEY, ANTHROPIC_ADMIN_TOKEN,
+// ANTHROPIC_API_KEY) or from an explicit Gateway.
+
+#include
+
+#include "anthropic/admin/gateway.h"
+#include "anthropic/admin/services/access.h"
+#include "anthropic/admin/services/agents.h"
+#include "anthropic/admin/services/analytics.h"
+#include "anthropic/admin/services/claude_tag.h"
+#include "anthropic/admin/services/deployments.h"
+#include "anthropic/admin/services/dreams.h"
+#include "anthropic/admin/services/environments.h"
+#include "anthropic/admin/services/identity.h"
+#include "anthropic/admin/services/memory.h"
+#include "anthropic/admin/services/plugins.h"
+#include "anthropic/admin/services/reports.h"
+#include "anthropic/admin/services/sessions.h"
+#include "anthropic/admin/services/spend_limits.h"
+#include "anthropic/admin/services/telemetry.h"
+#include "anthropic/admin/services/tunnels.h"
+#include "anthropic/admin/services/user_profiles.h"
+#include "anthropic/admin/services/vaults.h"
+#include "anthropic/admin/services/workspaces.h"
+
+namespace molo::anthropic::admin {
+
+class AdminApi {
+ public:
+ explicit AdminApi(std::shared_ptr gateway)
+ : gateway_(std::move(gateway)),
+ federation_issuers_(gateway_),
+ federation_rules_(gateway_),
+ federation_rules_workspaces_(gateway_),
+ rbac_groups_(gateway_),
+ rbac_groups_members_(gateway_),
+ rbac_roles_(gateway_),
+ rbac_roles_permissions_(gateway_),
+ service_accounts_(gateway_),
+ service_accounts_workspaces_(gateway_),
+ agents_(gateway_),
+ agents_versions_(gateway_),
+ analytics_apps_chat_projects_(gateway_),
+ analytics_artifacts_(gateway_),
+ analytics_connectors_(gateway_),
+ analytics_cost_(gateway_),
+ analytics_cost_report_(gateway_),
+ analytics_plugins_(gateway_),
+ analytics_skills_(gateway_),
+ analytics_summaries_(gateway_),
+ analytics_usage_(gateway_),
+ analytics_usage_report_(gateway_),
+ analytics_user_cost_report_(gateway_),
+ analytics_user_usage_report_(gateway_),
+ analytics_users_(gateway_),
+ claude_tag_bundles_(gateway_),
+ claude_tag_bundles_targets_(gateway_),
+ claude_tag_slack_channels_(gateway_),
+ claude_tag_slack_workspaces_(gateway_),
+ deployment_runs_(gateway_),
+ deployments_(gateway_),
+ dreams_(gateway_),
+ environments_(gateway_),
+ environments_work_(gateway_),
+ api_keys_(gateway_),
+ compliance_settings_(gateway_),
+ external_keys_(gateway_),
+ invites_(gateway_),
+ organization_(gateway_),
+ rate_limits_(gateway_),
+ users_(gateway_),
+ memory_stores_(gateway_),
+ memory_stores_memories_(gateway_),
+ memory_stores_memory_versions_(gateway_),
+ plugin_marketplaces_(gateway_),
+ plugins_(gateway_),
+ plugins_installation_settings_(gateway_),
+ plugins_shares_(gateway_),
+ plugins_versions_(gateway_),
+ cost_report_(gateway_),
+ usage_report_(gateway_),
+ sessions_(gateway_),
+ sessions_events_(gateway_),
+ sessions_resources_(gateway_),
+ sessions_threads_(gateway_),
+ sessions_threads_events_(gateway_),
+ spend_limits_(gateway_),
+ spend_limits_effective_(gateway_),
+ spend_limits_increase_requests_(gateway_),
+ telemetry_destinations_(gateway_),
+ telemetry_destinations_workspaces_(gateway_),
+ webhooks_(gateway_),
+ mcp_tunnels_(gateway_),
+ mcp_tunnels_certificates_(gateway_),
+ tunnels_(gateway_),
+ tunnels_certificates_(gateway_),
+ user_profiles_(gateway_),
+ user_profiles_action_urls_(gateway_),
+ vaults_(gateway_),
+ vaults_credentials_(gateway_),
+ workspaces_(gateway_),
+ workspaces_members_(gateway_),
+ workspaces_rate_limits_(gateway_),
+ workspaces_service_accounts_(gateway_) {}
+ static AdminApi from_env() { return AdminApi(Gateway::from_env()); }
+
+ const Gateway& gateway() const { return *gateway_; }
+
+ const FederationIssuers& federation_issuers() const { return federation_issuers_; }
+ const FederationRules& federation_rules() const { return federation_rules_; }
+ const FederationRuleWorkspaces& federation_rules_workspaces() const { return federation_rules_workspaces_; }
+ const RbacGroups& rbac_groups() const { return rbac_groups_; }
+ const RbacGroupsMembers& rbac_groups_members() const { return rbac_groups_members_; }
+ const RbacRoles& rbac_roles() const { return rbac_roles_; }
+ const RbacRolesPermissions& rbac_roles_permissions() const { return rbac_roles_permissions_; }
+ const ServiceAccounts& service_accounts() const { return service_accounts_; }
+ const ServiceAccountWorkspaces& service_accounts_workspaces() const { return service_accounts_workspaces_; }
+ const Agents& agents() const { return agents_; }
+ const AgentsVersions& agents_versions() const { return agents_versions_; }
+ const AnalyticsAppsChatProjects& analytics_apps_chat_projects() const { return analytics_apps_chat_projects_; }
+ const AnalyticsArtifacts& analytics_artifacts() const { return analytics_artifacts_; }
+ const AnalyticsConnectors& analytics_connectors() const { return analytics_connectors_; }
+ const AnalyticsCost& analytics_cost() const { return analytics_cost_; }
+ const AnalyticsCostReport& analytics_cost_report() const { return analytics_cost_report_; }
+ const AnalyticsPlugins& analytics_plugins() const { return analytics_plugins_; }
+ const AnalyticsSkills& analytics_skills() const { return analytics_skills_; }
+ const AnalyticsSummaries& analytics_summaries() const { return analytics_summaries_; }
+ const AnalyticsUsage& analytics_usage() const { return analytics_usage_; }
+ const AnalyticsUsageReport& analytics_usage_report() const { return analytics_usage_report_; }
+ const AnalyticsUserCostReport& analytics_user_cost_report() const { return analytics_user_cost_report_; }
+ const AnalyticsUserUsageReport& analytics_user_usage_report() const { return analytics_user_usage_report_; }
+ const AnalyticsUsers& analytics_users() const { return analytics_users_; }
+ const ClaudeTagBundles& claude_tag_bundles() const { return claude_tag_bundles_; }
+ const ClaudeTagBundlesTargets& claude_tag_bundles_targets() const { return claude_tag_bundles_targets_; }
+ const ClaudeTagSlackChannels& claude_tag_slack_channels() const { return claude_tag_slack_channels_; }
+ const ClaudeTagSlackWorkspaces& claude_tag_slack_workspaces() const { return claude_tag_slack_workspaces_; }
+ const DeploymentRuns& deployment_runs() const { return deployment_runs_; }
+ const Deployments& deployments() const { return deployments_; }
+ const Dreams& dreams() const { return dreams_; }
+ const Environments& environments() const { return environments_; }
+ const EnvironmentsWork& environments_work() const { return environments_work_; }
+ const ApiKeys& api_keys() const { return api_keys_; }
+ const ComplianceSettings& compliance_settings() const { return compliance_settings_; }
+ const ExternalKeys& external_keys() const { return external_keys_; }
+ const Invites& invites() const { return invites_; }
+ const Organization& organization() const { return organization_; }
+ const RateLimits& rate_limits() const { return rate_limits_; }
+ const Users& users() const { return users_; }
+ const MemoryStores& memory_stores() const { return memory_stores_; }
+ const MemoryStoresMemories& memory_stores_memories() const { return memory_stores_memories_; }
+ const MemoryStoresMemoryVersions& memory_stores_memory_versions() const { return memory_stores_memory_versions_; }
+ const PluginMarketplaces& plugin_marketplaces() const { return plugin_marketplaces_; }
+ const Plugins& plugins() const { return plugins_; }
+ const PluginsInstallationSettings& plugins_installation_settings() const { return plugins_installation_settings_; }
+ const PluginsShares& plugins_shares() const { return plugins_shares_; }
+ const PluginsVersions& plugins_versions() const { return plugins_versions_; }
+ const CostReports& cost_report() const { return cost_report_; }
+ const UsageReports& usage_report() const { return usage_report_; }
+ const Sessions& sessions() const { return sessions_; }
+ const SessionsEvents& sessions_events() const { return sessions_events_; }
+ const SessionsResources& sessions_resources() const { return sessions_resources_; }
+ const SessionsThreads& sessions_threads() const { return sessions_threads_; }
+ const SessionsThreadsEvents& sessions_threads_events() const { return sessions_threads_events_; }
+ const SpendLimits& spend_limits() const { return spend_limits_; }
+ const SpendLimitsEffective& spend_limits_effective() const { return spend_limits_effective_; }
+ const SpendLimitsIncreaseRequests& spend_limits_increase_requests() const { return spend_limits_increase_requests_; }
+ const TelemetryDestinations& telemetry_destinations() const { return telemetry_destinations_; }
+ const TelemetryDestinationsWorkspaces& telemetry_destinations_workspaces() const { return telemetry_destinations_workspaces_; }
+ const Webhooks& webhooks() const { return webhooks_; }
+ const McpTunnels& mcp_tunnels() const { return mcp_tunnels_; }
+ const McpTunnelCertificates& mcp_tunnels_certificates() const { return mcp_tunnels_certificates_; }
+ const Tunnels& tunnels() const { return tunnels_; }
+ const TunnelsCertificates& tunnels_certificates() const { return tunnels_certificates_; }
+ const UserProfiles& user_profiles() const { return user_profiles_; }
+ const UserProfilesActionUrls& user_profiles_action_urls() const { return user_profiles_action_urls_; }
+ const Vaults& vaults() const { return vaults_; }
+ const VaultsCredentials& vaults_credentials() const { return vaults_credentials_; }
+ const Workspaces& workspaces() const { return workspaces_; }
+ const WorkspaceMembers& workspaces_members() const { return workspaces_members_; }
+ const WorkspaceRateLimits& workspaces_rate_limits() const { return workspaces_rate_limits_; }
+ const WorkspaceServiceAccounts& workspaces_service_accounts() const { return workspaces_service_accounts_; }
+
+ private:
+ std::shared_ptr gateway_;
+ FederationIssuers federation_issuers_;
+ FederationRules federation_rules_;
+ FederationRuleWorkspaces federation_rules_workspaces_;
+ RbacGroups rbac_groups_;
+ RbacGroupsMembers rbac_groups_members_;
+ RbacRoles rbac_roles_;
+ RbacRolesPermissions rbac_roles_permissions_;
+ ServiceAccounts service_accounts_;
+ ServiceAccountWorkspaces service_accounts_workspaces_;
+ Agents agents_;
+ AgentsVersions agents_versions_;
+ AnalyticsAppsChatProjects analytics_apps_chat_projects_;
+ AnalyticsArtifacts analytics_artifacts_;
+ AnalyticsConnectors analytics_connectors_;
+ AnalyticsCost analytics_cost_;
+ AnalyticsCostReport analytics_cost_report_;
+ AnalyticsPlugins analytics_plugins_;
+ AnalyticsSkills analytics_skills_;
+ AnalyticsSummaries analytics_summaries_;
+ AnalyticsUsage analytics_usage_;
+ AnalyticsUsageReport analytics_usage_report_;
+ AnalyticsUserCostReport analytics_user_cost_report_;
+ AnalyticsUserUsageReport analytics_user_usage_report_;
+ AnalyticsUsers analytics_users_;
+ ClaudeTagBundles claude_tag_bundles_;
+ ClaudeTagBundlesTargets claude_tag_bundles_targets_;
+ ClaudeTagSlackChannels claude_tag_slack_channels_;
+ ClaudeTagSlackWorkspaces claude_tag_slack_workspaces_;
+ DeploymentRuns deployment_runs_;
+ Deployments deployments_;
+ Dreams dreams_;
+ Environments environments_;
+ EnvironmentsWork environments_work_;
+ ApiKeys api_keys_;
+ ComplianceSettings compliance_settings_;
+ ExternalKeys external_keys_;
+ Invites invites_;
+ Organization organization_;
+ RateLimits rate_limits_;
+ Users users_;
+ MemoryStores memory_stores_;
+ MemoryStoresMemories memory_stores_memories_;
+ MemoryStoresMemoryVersions memory_stores_memory_versions_;
+ PluginMarketplaces plugin_marketplaces_;
+ Plugins plugins_;
+ PluginsInstallationSettings plugins_installation_settings_;
+ PluginsShares plugins_shares_;
+ PluginsVersions plugins_versions_;
+ CostReports cost_report_;
+ UsageReports usage_report_;
+ Sessions sessions_;
+ SessionsEvents sessions_events_;
+ SessionsResources sessions_resources_;
+ SessionsThreads sessions_threads_;
+ SessionsThreadsEvents sessions_threads_events_;
+ SpendLimits spend_limits_;
+ SpendLimitsEffective spend_limits_effective_;
+ SpendLimitsIncreaseRequests spend_limits_increase_requests_;
+ TelemetryDestinations telemetry_destinations_;
+ TelemetryDestinationsWorkspaces telemetry_destinations_workspaces_;
+ Webhooks webhooks_;
+ McpTunnels mcp_tunnels_;
+ McpTunnelCertificates mcp_tunnels_certificates_;
+ Tunnels tunnels_;
+ TunnelsCertificates tunnels_certificates_;
+ UserProfiles user_profiles_;
+ UserProfilesActionUrls user_profiles_action_urls_;
+ Vaults vaults_;
+ VaultsCredentials vaults_credentials_;
+ Workspaces workspaces_;
+ WorkspaceMembers workspaces_members_;
+ WorkspaceRateLimits workspaces_rate_limits_;
+ WorkspaceServiceAccounts workspaces_service_accounts_;
+};
+
+} // namespace molo::anthropic::admin
diff --git a/src/anthropic/admin/calls.cpp b/src/anthropic/admin/calls.cpp
new file mode 100644
index 0000000..4f79d35
--- /dev/null
+++ b/src/anthropic/admin/calls.cpp
@@ -0,0 +1,291 @@
+// GENERATED by src/anthropic/admin/tools/check_spec.py --emit. Do not edit by hand:
+// the table is verified against the SDK source and the reference pages.
+#include "anthropic/admin/calls.h"
+
+#include
+
+namespace molo::anthropic::admin {
+
+// CALLS-BEGIN (parsed by tools/check_spec.py; one row per line)
+static const CallSpec kCalls[] = {
+ {Call::kAnalyticsAppsChatProjectsList, "organization.analytics.apps.chat.projects.list", "GET", "/v1/organizations/analytics/apps/chat/projects", "api/beta/organization/analytics/apps/chat/projects/list", "ProjectListParams", "BetaAnalyticsProjectActivity", "", "", "date,ending_date,filter[],group_by[],limit,order,order_by,page,starting_date", "", "", Auth::kAdmin, Kind::kRead, Page::kCursor, Wire::kJson, false, false},
+ {Call::kAnalyticsArtifactsList, "organization.analytics.artifacts.list", "GET", "/v1/organizations/analytics/artifacts", "api/beta/organization/analytics/artifacts/list", "ArtifactListParams", "BetaAnalyticsArtifactActivity", "", "date", "date,filter[],group_by[],limit,page", "", "", Auth::kAdmin, Kind::kRead, Page::kCursor, Wire::kJson, false, false},
+ {Call::kAnalyticsConnectorsList, "organization.analytics.connectors.list", "GET", "/v1/organizations/analytics/connectors", "api/beta/organization/analytics/connectors/list", "ConnectorListParams", "BetaAnalyticsConnectorActivity", "", "", "date,ending_date,filter[],group_by[],limit,order,order_by,page,starting_date", "", "", Auth::kAdmin, Kind::kRead, Page::kCursor, Wire::kJson, false, false},
+ {Call::kAnalyticsCostList, "organization.analytics.cost.list", "GET", "/v1/organizations/analytics/cost", "", "CostListParams", "BetaAnalyticsCostItem", "", "starting_at", "starting_at,actor_ids[],actor_types[],agent_ids[],api_key_ids[],claude_tag_categories[],claude_tag_user_ids[],context_windows[],deployment_ids[],ending_at,environment_ids[],exclude_deleted_users,group_by[],inference_geos[],limit,models[],order,order_by,page,products[],rbac_group_ids[],service_tiers[],session_ids[],slack_channel_ids[],speeds[],time_bucket_width,user_profile_ids[],workspace_ids[]", "", "analytics-usage-cost-2026-08-24", Auth::kAdmin, Kind::kRead, Page::kReport, Wire::kJson, false, false},
+ {Call::kAnalyticsCostReportList, "organization.analytics.cost_report.list", "GET", "/v1/organizations/analytics/cost_report", "api/beta/organization/analytics/cost_report/list", "CostReportListParams", "BetaAnalyticsCostReportTimeBucket", "", "starting_at", "starting_at,bucket_width,claude_tag_categories[],claude_tag_user_ids[],context_windows[],ending_at,group_by[],inference_geos[],limit,models[],page,products[],rbac_group_ids[],slack_channel_ids[],speeds[],user_ids[]", "", "", Auth::kAdmin, Kind::kRead, Page::kReport, Wire::kJson, false, false},
+ {Call::kAnalyticsPluginsList, "organization.analytics.plugins.list", "GET", "/v1/organizations/analytics/plugins", "api/beta/organization/analytics/plugins/list", "PluginListParams", "BetaAnalyticsPluginActivity", "", "", "date,ending_date,filter[],group_by[],limit,order,order_by,page,starting_date", "", "", Auth::kAdmin, Kind::kRead, Page::kCursor, Wire::kJson, false, false},
+ {Call::kAnalyticsSkillsList, "organization.analytics.skills.list", "GET", "/v1/organizations/analytics/skills", "api/beta/organization/analytics/skills/list", "SkillListParams", "BetaAnalyticsSkillActivity", "", "", "date,ending_date,filter[],group_by[],limit,order,order_by,page,starting_date", "", "", Auth::kAdmin, Kind::kRead, Page::kCursor, Wire::kJson, false, false},
+ {Call::kAnalyticsSummariesList, "organization.analytics.summaries.list", "GET", "/v1/organizations/analytics/summaries", "api/beta/organization/analytics/summaries/list", "SummaryListParams", "BetaAnalyticsSingleDayActivitySummary", "", "starting_date", "starting_date,ending_date,filter[],limit,page", "", "", Auth::kAdmin, Kind::kRead, Page::kCursor, Wire::kJson, false, false},
+ {Call::kAnalyticsUsageList, "organization.analytics.usage.list", "GET", "/v1/organizations/analytics/usage", "", "UsageListParams", "BetaAnalyticsUsageItem", "", "starting_at", "starting_at,actor_ids[],actor_types[],agent_ids[],api_key_ids[],claude_tag_categories[],claude_tag_user_ids[],context_windows[],deployment_ids[],ending_at,environment_ids[],exclude_deleted_users,group_by[],inference_geos[],limit,models[],order,order_by,page,products[],rbac_group_ids[],service_tiers[],session_ids[],slack_channel_ids[],speeds[],time_bucket_width,user_profile_ids[],workspace_ids[]", "", "analytics-usage-cost-2026-08-24", Auth::kAdmin, Kind::kRead, Page::kReport, Wire::kJson, false, false},
+ {Call::kAnalyticsUsageReportList, "organization.analytics.usage_report.list", "GET", "/v1/organizations/analytics/usage_report", "api/beta/organization/analytics/usage_report/list", "UsageReportListParams", "BetaAnalyticsUsageReportTimeBucket", "", "starting_at", "starting_at,bucket_width,claude_tag_categories[],claude_tag_user_ids[],context_windows[],ending_at,group_by[],inference_geos[],limit,models[],page,products[],rbac_group_ids[],slack_channel_ids[],speeds[],user_ids[]", "", "", Auth::kAdmin, Kind::kRead, Page::kReport, Wire::kJson, false, false},
+ {Call::kAnalyticsUserCostReportList, "organization.analytics.user_cost_report.list", "GET", "/v1/organizations/analytics/user_cost_report", "api/beta/organization/analytics/user_cost_report/list", "UserCostReportListParams", "BetaAnalyticsCostUsersItem", "", "starting_at", "starting_at,bucket_width,claude_tag_categories[],claude_tag_user_ids[],context_windows[],ending_at,exclude_deleted_users,group_by[],inference_geos[],limit,models[],order,order_by,page,products[],rbac_group_ids[],slack_channel_ids[],speeds[],user_ids[]", "", "", Auth::kAdmin, Kind::kRead, Page::kReport, Wire::kJson, false, false},
+ {Call::kAnalyticsUserUsageReportList, "organization.analytics.user_usage_report.list", "GET", "/v1/organizations/analytics/user_usage_report", "api/beta/organization/analytics/user_usage_report/list", "UserUsageReportListParams", "BetaAnalyticsUsageUsersItem", "", "starting_at", "starting_at,bucket_width,claude_tag_categories[],claude_tag_user_ids[],context_windows[],ending_at,exclude_deleted_users,group_by[],inference_geos[],limit,models[],order,order_by,page,products[],rbac_group_ids[],slack_channel_ids[],speeds[],user_ids[]", "", "", Auth::kAdmin, Kind::kRead, Page::kReport, Wire::kJson, false, false},
+ {Call::kAnalyticsUsersList, "organization.analytics.users.list", "GET", "/v1/organizations/analytics/users", "api/beta/organization/analytics/users/list", "UserListParams", "BetaAnalyticsUserActivity", "", "", "date,ending_date,filter[],group_by[],limit,order,order_by,page,starting_date", "", "", Auth::kAdmin, Kind::kRead, Page::kCursor, Wire::kJson, false, false},
+ {Call::kApiKeysList, "organization.api_keys.list", "GET", "/v1/organizations/api_keys", "api/organization/api_keys/list", "ApiKeyListParams", "BetaAPIKey", "", "", "after_id,before_id,created_by_user_id,limit,status,workspace_id", "", "", Auth::kAdmin, Kind::kRead, Page::kIds, Wire::kJson, true, false},
+ {Call::kApiKeysRetrieve, "organization.api_keys.retrieve", "GET", "/v1/organizations/api_keys/{api_key_id}", "api/organization/api_keys/retrieve", "", "BetaAPIKey", "", "", "", "", "", Auth::kAdmin, Kind::kRead, Page::kNone, Wire::kJson, false, false},
+ {Call::kApiKeysUpdate, "organization.api_keys.update", "POST", "/v1/organizations/api_keys/{api_key_id}", "api/organization/api_keys/update", "ApiKeyUpdateParams", "BetaAPIKey", "name,status", "", "", "", "", Auth::kAdmin, Kind::kWrite, Page::kNone, Wire::kJson, false, false},
+ {Call::kClaudeTagBundlesList, "organization.claude_tag.bundles.list", "GET", "/v1/organizations/claude_tag/bundles", "guide:manage-claude/claude-tag-api", "BundleListParams", "BetaClaudeTagBundle", "", "", "limit,page", "", "experimental-claude-tag-2026-10-21", Auth::kAdmin, Kind::kRead, Page::kCursor, Wire::kJson, false, false},
+ {Call::kClaudeTagBundlesRetrieve, "organization.claude_tag.bundles.retrieve", "GET", "/v1/organizations/claude_tag/bundles/{bundle_id}", "guide:manage-claude/claude-tag-api", "", "BetaClaudeTagBundle", "", "", "", "", "experimental-claude-tag-2026-10-21", Auth::kAdmin, Kind::kRead, Page::kNone, Wire::kJson, false, false},
+ {Call::kClaudeTagBundlesTargetsCreate, "organization.claude_tag.bundles.targets.create", "POST", "/v1/organizations/claude_tag/bundles/{bundle_id}/targets", "guide:manage-claude/claude-tag-api", "TargetCreateParams", "BetaClaudeTagBundleTarget", "", "", "", "", "experimental-claude-tag-2026-10-21", Auth::kAdmin, Kind::kWrite, Page::kNone, Wire::kJson, false, false},
+ {Call::kClaudeTagBundlesTargetsDelete, "organization.claude_tag.bundles.targets.delete", "DELETE", "/v1/organizations/claude_tag/bundles/{bundle_id}/targets/{target_id}", "guide:manage-claude/claude-tag-api", "", "BetaClaudeTagDeletedBundleTarget", "", "", "", "", "experimental-claude-tag-2026-10-21", Auth::kAdmin, Kind::kDestructive, Page::kNone, Wire::kJson, false, false},
+ {Call::kClaudeTagBundlesTargetsList, "organization.claude_tag.bundles.targets.list", "GET", "/v1/organizations/claude_tag/bundles/{bundle_id}/targets", "guide:manage-claude/claude-tag-api", "TargetListParams", "BetaClaudeTagBundleTarget", "", "", "limit,page", "", "experimental-claude-tag-2026-10-21", Auth::kAdmin, Kind::kRead, Page::kCursor, Wire::kJson, false, false},
+ {Call::kClaudeTagBundlesTargetsRetrieve, "organization.claude_tag.bundles.targets.retrieve", "GET", "/v1/organizations/claude_tag/bundles/{bundle_id}/targets/{target_id}", "guide:manage-claude/claude-tag-api", "", "BetaClaudeTagBundleTarget", "", "", "", "", "experimental-claude-tag-2026-10-21", Auth::kAdmin, Kind::kRead, Page::kNone, Wire::kJson, false, false},
+ {Call::kClaudeTagSlackChannelsCreate, "organization.claude_tag.slack_channels.create", "POST", "/v1/organizations/claude_tag/slack_channels", "guide:manage-claude/claude-tag-api", "SlackChannelCreateParams", "BetaClaudeTagSlackChannel", "slack,settings", "slack", "", "", "experimental-claude-tag-2026-10-21", Auth::kAdmin, Kind::kWrite, Page::kNone, Wire::kJson, false, false},
+ {Call::kClaudeTagSlackChannelsDelete, "organization.claude_tag.slack_channels.delete", "DELETE", "/v1/organizations/claude_tag/slack_channels/{id}", "guide:manage-claude/claude-tag-api", "", "BetaClaudeTagDeletedSlackChannel", "", "", "", "", "experimental-claude-tag-2026-10-21", Auth::kAdmin, Kind::kDestructive, Page::kNone, Wire::kJson, false, false},
+ {Call::kClaudeTagSlackChannelsList, "organization.claude_tag.slack_channels.list", "GET", "/v1/organizations/claude_tag/slack_channels", "guide:manage-claude/claude-tag-api", "SlackChannelListParams", "BetaClaudeTagSlackChannel", "", "slack_workspace_id", "slack_workspace_id,include_inherited,limit,page,slack_channel_id", "", "experimental-claude-tag-2026-10-21", Auth::kAdmin, Kind::kRead, Page::kCursor, Wire::kJson, false, false},
+ {Call::kClaudeTagSlackChannelsRetrieve, "organization.claude_tag.slack_channels.retrieve", "GET", "/v1/organizations/claude_tag/slack_channels/{id}", "guide:manage-claude/claude-tag-api", "SlackChannelRetrieveParams", "BetaClaudeTagSlackChannel", "", "", "include_inherited", "", "experimental-claude-tag-2026-10-21", Auth::kAdmin, Kind::kRead, Page::kNone, Wire::kJson, false, false},
+ {Call::kClaudeTagSlackChannelsUpdate, "organization.claude_tag.slack_channels.update", "POST", "/v1/organizations/claude_tag/slack_channels/{id}", "guide:manage-claude/claude-tag-api", "SlackChannelUpdateParams", "BetaClaudeTagSlackChannel", "settings", "settings", "", "", "experimental-claude-tag-2026-10-21", Auth::kAdmin, Kind::kWrite, Page::kNone, Wire::kJson, false, false},
+ {Call::kClaudeTagSlackWorkspacesList, "organization.claude_tag.slack_workspaces.list", "GET", "/v1/organizations/claude_tag/slack_workspaces", "guide:manage-claude/claude-tag-api", "SlackWorkspaceListParams", "BetaClaudeTagSlackWorkspace", "", "", "include_inherited,limit,page,slack_workspace_id", "", "experimental-claude-tag-2026-10-21", Auth::kAdmin, Kind::kRead, Page::kCursor, Wire::kJson, false, false},
+ {Call::kClaudeTagSlackWorkspacesRetrieve, "organization.claude_tag.slack_workspaces.retrieve", "GET", "/v1/organizations/claude_tag/slack_workspaces/{id}", "guide:manage-claude/claude-tag-api", "SlackWorkspaceRetrieveParams", "BetaClaudeTagSlackWorkspace", "", "", "include_inherited", "", "experimental-claude-tag-2026-10-21", Auth::kAdmin, Kind::kRead, Page::kNone, Wire::kJson, false, false},
+ {Call::kClaudeTagSlackWorkspacesUpdate, "organization.claude_tag.slack_workspaces.update", "POST", "/v1/organizations/claude_tag/slack_workspaces/{id}", "guide:manage-claude/claude-tag-api", "SlackWorkspaceUpdateParams", "BetaClaudeTagSlackWorkspace", "settings", "settings", "", "", "experimental-claude-tag-2026-10-21", Auth::kAdmin, Kind::kWrite, Page::kNone, Wire::kJson, false, false},
+ {Call::kComplianceSettingsRetrieve, "organization.compliance_settings.retrieve", "GET", "/v1/organizations/compliance_settings", "api/organization/compliance_settings/retrieve", "", "BetaComplianceSettings", "", "", "", "", "", Auth::kAdmin, Kind::kRead, Page::kNone, Wire::kJson, false, false},
+ {Call::kComplianceSettingsUpdate, "organization.compliance_settings.update", "POST", "/v1/organizations/compliance_settings", "api/organization/compliance_settings/update", "ComplianceSettingUpdateParams", "BetaComplianceSettings", "state", "state", "", "", "", Auth::kAdmin, Kind::kWrite, Page::kNone, Wire::kJson, false, false},
+ {Call::kCostReportRetrieve, "organization.cost_report.retrieve", "GET", "/v1/organizations/cost_report", "api/beta/organization/cost_report/retrieve", "", "BetaCostReport", "", "starting_at", "starting_at,bucket_width,ending_at,group_by[],limit,page", "", "", Auth::kAdmin, Kind::kRead, Page::kReport, Wire::kJson, false, true},
+ {Call::kExternalKeysCreate, "organization.external_keys.create", "POST", "/v1/organizations/external_keys", "api/organization/external_keys/create", "ExternalKeyCreateParams", "BetaExternalKey", "provider_config,display_name,geo", "provider_config", "", "", "", Auth::kAdmin, Kind::kWrite, Page::kNone, Wire::kJson, false, false},
+ {Call::kExternalKeysDelete, "organization.external_keys.delete", "DELETE", "/v1/organizations/external_keys/{external_key_id}", "api/organization/external_keys/delete", "", "ExternalKeyDeleteResponse", "", "", "", "", "", Auth::kAdmin, Kind::kDestructive, Page::kNone, Wire::kJson, false, false},
+ {Call::kExternalKeysList, "organization.external_keys.list", "GET", "/v1/organizations/external_keys", "api/organization/external_keys/list", "ExternalKeyListParams", "BetaExternalKey", "", "", "limit,page", "", "", Auth::kAdmin, Kind::kRead, Page::kCursor, Wire::kJson, false, false},
+ {Call::kExternalKeysRetrieve, "organization.external_keys.retrieve", "GET", "/v1/organizations/external_keys/{external_key_id}", "api/organization/external_keys/retrieve", "", "BetaExternalKey", "", "", "", "", "", Auth::kAdmin, Kind::kRead, Page::kNone, Wire::kJson, false, false},
+ {Call::kExternalKeysUpdate, "organization.external_keys.update", "POST", "/v1/organizations/external_keys/{external_key_id}", "api/organization/external_keys/update", "ExternalKeyUpdateParams", "BetaExternalKey", "display_name,geo,provider_config", "", "", "", "", Auth::kAdmin, Kind::kWrite, Page::kNone, Wire::kJson, false, false},
+ {Call::kExternalKeysValidate, "organization.external_keys.validate", "POST", "/v1/organizations/external_keys/{external_key_id}/validate", "api/organization/external_keys/validate", "", "ExternalKeyValidateResponse", "", "", "", "", "", Auth::kAdmin, Kind::kWrite, Page::kNone, Wire::kJson, false, false},
+ {Call::kInvitesCreate, "organization.invites.create", "POST", "/v1/organizations/invites", "api/organization/invites/create", "InviteCreateParams", "BetaOrganizationInvite", "email,role,rbac_group_ids", "email,role", "", "", "", Auth::kAdmin, Kind::kWrite, Page::kNone, Wire::kJson, false, false},
+ {Call::kInvitesDelete, "organization.invites.delete", "DELETE", "/v1/organizations/invites/{invite_id}", "api/organization/invites/delete", "", "InviteDeleteResponse", "", "", "", "", "", Auth::kAdmin, Kind::kDestructive, Page::kNone, Wire::kJson, false, false},
+ {Call::kInvitesList, "organization.invites.list", "GET", "/v1/organizations/invites", "api/organization/invites/list", "InviteListParams", "BetaOrganizationInvite", "", "", "after_id,before_id,email,limit,roles[],statuses[]", "", "", Auth::kAdmin, Kind::kRead, Page::kIds, Wire::kJson, false, false},
+ {Call::kInvitesRetrieve, "organization.invites.retrieve", "GET", "/v1/organizations/invites/{invite_id}", "api/organization/invites/retrieve", "", "BetaOrganizationInvite", "", "", "", "", "", Auth::kAdmin, Kind::kRead, Page::kNone, Wire::kJson, false, false},
+ {Call::kMcpTunnelsArchive, "organization.mcp_tunnels.archive", "POST", "/v1/organizations/tunnels/{tunnel_id}/archive", "api/beta/organization/mcp_tunnels/archive", "", "BetaMcpTunnel", "", "", "", "", "mcp-tunnels-2026-06-22", Auth::kAdmin, Kind::kDestructive, Page::kNone, Wire::kJson, false, true},
+ {Call::kMcpTunnelsCertificatesArchive, "organization.mcp_tunnels.certificates.archive", "POST", "/v1/organizations/tunnels/{tunnel_id}/certificates/{certificate_id}/archive", "api/beta/organization/mcp_tunnels/tunnel_certificates/archive", "", "BetaMcpTunnelCertificate", "", "", "", "", "mcp-tunnels-2026-06-22", Auth::kAdmin, Kind::kDestructive, Page::kNone, Wire::kJson, false, true},
+ {Call::kMcpTunnelsCertificatesCreate, "organization.mcp_tunnels.certificates.create", "POST", "/v1/organizations/tunnels/{tunnel_id}/certificates", "api/beta/organization/mcp_tunnels/tunnel_certificates/create", "", "BetaMcpTunnelCertificate", "ca_certificate_pem", "ca_certificate_pem", "", "", "mcp-tunnels-2026-06-22", Auth::kAdmin, Kind::kWrite, Page::kNone, Wire::kJson, false, true},
+ {Call::kMcpTunnelsCertificatesList, "organization.mcp_tunnels.certificates.list", "GET", "/v1/organizations/tunnels/{tunnel_id}/certificates", "api/beta/organization/mcp_tunnels/tunnel_certificates/list", "", "BetaMcpTunnelCertificate", "", "", "include_archived,limit,page", "", "mcp-tunnels-2026-06-22", Auth::kAdmin, Kind::kRead, Page::kCursor, Wire::kJson, false, true},
+ {Call::kMcpTunnelsCertificatesRetrieve, "organization.mcp_tunnels.certificates.retrieve", "GET", "/v1/organizations/tunnels/{tunnel_id}/certificates/{certificate_id}", "api/beta/organization/mcp_tunnels/tunnel_certificates/retrieve", "", "BetaMcpTunnelCertificate", "", "", "", "", "mcp-tunnels-2026-06-22", Auth::kAdmin, Kind::kRead, Page::kNone, Wire::kJson, false, true},
+ {Call::kMcpTunnelsList, "organization.mcp_tunnels.list", "GET", "/v1/organizations/tunnels", "api/beta/organization/mcp_tunnels/list", "", "BetaMcpTunnel", "", "", "include_archived,limit,page,workspace_id", "", "mcp-tunnels-2026-06-22", Auth::kAdmin, Kind::kRead, Page::kCursor, Wire::kJson, false, true},
+ {Call::kMcpTunnelsRetrieve, "organization.mcp_tunnels.retrieve", "GET", "/v1/organizations/tunnels/{tunnel_id}", "api/beta/organization/mcp_tunnels/retrieve", "", "BetaMcpTunnel", "", "", "", "", "mcp-tunnels-2026-06-22", Auth::kAdmin, Kind::kRead, Page::kNone, Wire::kJson, false, true},
+ {Call::kMcpTunnelsRevealToken, "organization.mcp_tunnels.reveal_token", "POST", "/v1/organizations/tunnels/{tunnel_id}/reveal_token", "api/beta/organization/mcp_tunnels/reveal_token", "", "BetaMcpTunnelToken", "", "", "", "", "mcp-tunnels-2026-06-22", Auth::kAdmin, Kind::kWrite, Page::kNone, Wire::kJson, false, true},
+ {Call::kMcpTunnelsRotateToken, "organization.mcp_tunnels.rotate_token", "POST", "/v1/organizations/tunnels/{tunnel_id}/rotate_token", "api/beta/organization/mcp_tunnels/rotate_token", "", "BetaMcpTunnelToken", "reason", "", "", "", "mcp-tunnels-2026-06-22", Auth::kAdmin, Kind::kDestructive, Page::kNone, Wire::kJson, false, true},
+ {Call::kOrganizationRetrieve, "organization.retrieve", "GET", "/v1/organizations/me", "api/organization/retrieve", "", "BetaOrganization", "", "", "", "", "", Auth::kAdmin, Kind::kRead, Page::kNone, Wire::kJson, false, false},
+ {Call::kPluginMarketplacesList, "organization.plugin_marketplaces.list", "GET", "/v1/organizations/plugin_marketplaces", "api/beta/organization/plugin_marketplaces/list", "PluginMarketplaceListParams", "BetaPluginMarketplace", "", "", "limit,organization_id,owner_type,page,source", "", "ce-plugins-2026-09-01", Auth::kAdmin, Kind::kRead, Page::kCursor, Wire::kJson, false, false},
+ {Call::kPluginMarketplacesRetrieve, "organization.plugin_marketplaces.retrieve", "GET", "/v1/organizations/plugin_marketplaces/{marketplace_id}", "api/beta/organization/plugin_marketplaces/retrieve", "PluginMarketplaceRetrieveParams", "BetaPluginMarketplace", "", "", "organization_id", "", "ce-plugins-2026-09-01", Auth::kAdmin, Kind::kRead, Page::kNone, Wire::kJson, false, false},
+ {Call::kPluginMarketplacesUpdate, "organization.plugin_marketplaces.update", "POST", "/v1/organizations/plugin_marketplaces/{marketplace_id}", "api/beta/organization/plugin_marketplaces/update", "PluginMarketplaceUpdateParams", "BetaPluginMarketplace", "default_installation_preference", "default_installation_preference", "", "", "ce-plugins-2026-09-01", Auth::kAdmin, Kind::kWrite, Page::kNone, Wire::kJson, false, false},
+ {Call::kPluginMarketplacesValidateArchive, "organization.plugin_marketplaces.validate_archive", "POST", "/v1/organizations/plugin_marketplaces/validate_archive", "api/beta/organization/plugin_marketplaces/validate_archive", "PluginMarketplaceValidateArchiveParams", "BetaPluginMarketplaceValidationReport", "archive", "archive", "", "", "ce-plugins-2026-09-01", Auth::kAdmin, Kind::kWrite, Page::kNone, Wire::kMultipart, false, false},
+ {Call::kPluginMarketplacesValidateRepository, "organization.plugin_marketplaces.validate_repository", "POST", "/v1/organizations/plugin_marketplaces/validate_repository", "api/beta/organization/plugin_marketplaces/validate_repository", "PluginMarketplaceValidateRepositoryParams", "BetaPluginMarketplaceValidationReport", "repository_url,ref", "repository_url", "", "", "ce-plugins-2026-09-01", Auth::kAdmin, Kind::kWrite, Page::kNone, Wire::kJson, false, false},
+ {Call::kPluginsCreate, "organization.plugins.create", "POST", "/v1/organizations/plugins", "api/beta/organization/plugins/create", "PluginCreateParams", "BetaPlugin", "files[],marketplace_id,release_notes", "files[]", "", "", "ce-plugins-2026-09-01", Auth::kAdmin, Kind::kWrite, Page::kNone, Wire::kMultipart, false, false},
+ {Call::kPluginsDelete, "organization.plugins.delete", "DELETE", "/v1/organizations/plugins/{plugin_id}", "api/beta/organization/plugins/delete", "", "BetaDeletedPlugin", "", "", "", "", "ce-plugins-2026-09-01", Auth::kAdmin, Kind::kDestructive, Page::kNone, Wire::kJson, false, false},
+ {Call::kPluginsInstallationSettingsList, "organization.plugins.installation_settings.list", "GET", "/v1/organizations/plugins/{plugin_id}/installation_settings", "api/beta/organization/plugins/installation_settings/list", "InstallationSettingListParams", "BetaPluginInstallationSetting", "", "", "limit,organization_id,page,target_type", "", "ce-plugins-2026-09-01", Auth::kAdmin, Kind::kRead, Page::kCursor, Wire::kJson, false, false},
+ {Call::kPluginsInstallationSettingsRemove, "organization.plugins.installation_settings.remove", "DELETE", "/v1/organizations/plugins/{plugin_id}/installation_settings/{target}", "api/beta/organization/plugins/installation_settings/remove", "", "BetaDeletedPluginInstallationSetting", "", "", "", "", "ce-plugins-2026-09-01", Auth::kAdmin, Kind::kDestructive, Page::kNone, Wire::kJson, false, false},
+ {Call::kPluginsInstallationSettingsSet, "organization.plugins.installation_settings.set", "POST", "/v1/organizations/plugins/{plugin_id}/installation_settings/{target}", "api/beta/organization/plugins/installation_settings/set", "InstallationSettingSetParams", "BetaPluginInstallationSetting", "installation_preference", "installation_preference", "", "", "ce-plugins-2026-09-01", Auth::kAdmin, Kind::kWrite, Page::kNone, Wire::kJson, false, false},
+ {Call::kPluginsList, "organization.plugins.list", "GET", "/v1/organizations/plugins", "api/beta/organization/plugins/list", "PluginListParams", "BetaPlugin", "", "", "created_at[gt],created_at[gte],created_at[lt],created_at[lte],limit,marketplace_id,organization_id,owner_type,owner_user_id,page", "", "ce-plugins-2026-09-01", Auth::kAdmin, Kind::kRead, Page::kCursor, Wire::kJson, false, false},
+ {Call::kPluginsRetrieve, "organization.plugins.retrieve", "GET", "/v1/organizations/plugins/{plugin_id}", "api/beta/organization/plugins/retrieve", "PluginRetrieveParams", "BetaPlugin", "", "", "organization_id", "", "ce-plugins-2026-09-01", Auth::kAdmin, Kind::kRead, Page::kNone, Wire::kJson, false, false},
+ {Call::kPluginsSharesList, "organization.plugins.shares.list", "GET", "/v1/organizations/plugins/{plugin_id}/shares", "api/beta/organization/plugins/shares/list", "ShareListParams", "BetaPluginShare", "", "", "limit,organization_id,page,target_type", "", "ce-plugins-2026-09-01", Auth::kAdmin, Kind::kRead, Page::kCursor, Wire::kJson, false, false},
+ {Call::kPluginsUpdate, "organization.plugins.update", "POST", "/v1/organizations/plugins/{plugin_id}", "api/beta/organization/plugins/update", "PluginUpdateParams", "BetaPlugin", "served_version_id", "served_version_id", "", "", "ce-plugins-2026-09-01", Auth::kAdmin, Kind::kWrite, Page::kNone, Wire::kJson, false, false},
+ {Call::kPluginsVersionsCreate, "organization.plugins.versions.create", "POST", "/v1/organizations/plugins/{plugin_id}/versions", "api/beta/organization/plugins/versions/create", "VersionCreateParams", "BetaPluginVersion", "files[],release_notes", "files[]", "", "", "ce-plugins-2026-09-01", Auth::kAdmin, Kind::kWrite, Page::kNone, Wire::kMultipart, false, false},
+ {Call::kPluginsVersionsDownload, "organization.plugins.versions.download", "GET", "/v1/organizations/plugins/{plugin_id}/versions/{version}/content", "api/beta/organization/plugins/versions/download", "VersionDownloadParams", "Binary", "", "", "organization_id", "", "ce-plugins-2026-09-01", Auth::kAdmin, Kind::kRead, Page::kNone, Wire::kRaw, false, false},
+ {Call::kPluginsVersionsList, "organization.plugins.versions.list", "GET", "/v1/organizations/plugins/{plugin_id}/versions", "api/beta/organization/plugins/versions/list", "VersionListParams", "BetaPluginVersion", "", "", "limit,organization_id,page", "", "ce-plugins-2026-09-01", Auth::kAdmin, Kind::kRead, Page::kCursor, Wire::kJson, false, false},
+ {Call::kPluginsVersionsRetrieve, "organization.plugins.versions.retrieve", "GET", "/v1/organizations/plugins/{plugin_id}/versions/{version}", "api/beta/organization/plugins/versions/retrieve", "VersionRetrieveParams", "BetaPluginVersion", "", "", "organization_id", "", "ce-plugins-2026-09-01", Auth::kAdmin, Kind::kRead, Page::kNone, Wire::kJson, false, false},
+ {Call::kRateLimitsList, "organization.rate_limits.list", "GET", "/v1/organizations/rate_limits", "api/organization/rate_limits/list", "RateLimitListParams", "BetaOrganizationRateLimit", "", "", "group_type,limit,model,page", "", "", Auth::kAdmin, Kind::kRead, Page::kCursor, Wire::kJson, false, false},
+ {Call::kRbacGroupsCreate, "organization.rbac_groups.create", "POST", "/v1/organizations/rbac_groups", "api/beta/organization/rbac_groups/create", "RbacGroupCreateParams", "BetaRBACGroup", "name", "name", "", "", "", Auth::kAdmin, Kind::kWrite, Page::kNone, Wire::kJson, false, false},
+ {Call::kRbacGroupsDelete, "organization.rbac_groups.delete", "DELETE", "/v1/organizations/rbac_groups/{rbac_group_id}", "api/beta/organization/rbac_groups/delete", "", "RBACGroupDeleteResponse", "", "", "", "", "", Auth::kAdmin, Kind::kDestructive, Page::kNone, Wire::kJson, false, false},
+ {Call::kRbacGroupsList, "organization.rbac_groups.list", "GET", "/v1/organizations/rbac_groups", "api/beta/organization/rbac_groups/list", "RbacGroupListParams", "BetaRBACGroup", "", "", "limit,page", "", "", Auth::kAdmin, Kind::kRead, Page::kCursor, Wire::kJson, false, false},
+ {Call::kRbacGroupsMembersAdd, "organization.rbac_groups.members.add", "POST", "/v1/organizations/rbac_groups/{rbac_group_id}/members", "api/beta/organization/rbac_groups/members/add", "MemberAddParams", "BetaRBACGroupMember", "user_id", "user_id", "", "", "", Auth::kAdmin, Kind::kWrite, Page::kNone, Wire::kJson, false, false},
+ {Call::kRbacGroupsMembersList, "organization.rbac_groups.members.list", "GET", "/v1/organizations/rbac_groups/{rbac_group_id}/members", "api/beta/organization/rbac_groups/members/list", "MemberListParams", "BetaRBACGroupMember", "", "", "limit,page", "", "", Auth::kAdmin, Kind::kRead, Page::kCursor, Wire::kJson, false, false},
+ {Call::kRbacGroupsMembersRemove, "organization.rbac_groups.members.remove", "DELETE", "/v1/organizations/rbac_groups/{rbac_group_id}/members/{user_id}", "api/beta/organization/rbac_groups/members/remove", "", "MemberRemoveResponse", "", "", "", "", "", Auth::kAdmin, Kind::kDestructive, Page::kNone, Wire::kJson, false, false},
+ {Call::kRbacGroupsRetrieve, "organization.rbac_groups.retrieve", "GET", "/v1/organizations/rbac_groups/{rbac_group_id}", "api/beta/organization/rbac_groups/retrieve", "", "BetaRBACGroup", "", "", "", "", "", Auth::kAdmin, Kind::kRead, Page::kNone, Wire::kJson, false, false},
+ {Call::kRbacGroupsUpdate, "organization.rbac_groups.update", "POST", "/v1/organizations/rbac_groups/{rbac_group_id}", "api/beta/organization/rbac_groups/update", "RbacGroupUpdateParams", "BetaRBACGroup", "name", "", "", "", "", Auth::kAdmin, Kind::kWrite, Page::kNone, Wire::kJson, false, false},
+ {Call::kRbacRolesList, "organization.rbac_roles.list", "GET", "/v1/organizations/rbac_roles", "api/beta/organization/rbac_roles/list", "RbacRoleListParams", "BetaRBACRole", "", "", "limit,page", "", "", Auth::kAdmin, Kind::kRead, Page::kCursor, Wire::kJson, false, false},
+ {Call::kRbacRolesPermissionsList, "organization.rbac_roles.permissions.list", "GET", "/v1/organizations/rbac_roles/{rbac_role_id}/permissions", "api/beta/organization/rbac_roles/permissions/list", "PermissionListParams", "BetaRBACRolePermission", "", "", "limit,page", "", "", Auth::kAdmin, Kind::kRead, Page::kCursor, Wire::kJson, false, false},
+ {Call::kRbacRolesRetrieve, "organization.rbac_roles.retrieve", "GET", "/v1/organizations/rbac_roles/{rbac_role_id}", "api/beta/organization/rbac_roles/retrieve", "", "BetaRBACRole", "", "", "", "", "", Auth::kAdmin, Kind::kRead, Page::kNone, Wire::kJson, false, false},
+ {Call::kSpendLimitsDelete, "organization.spend_limits.delete", "DELETE", "/v1/organizations/spend_limits/{spend_limit_id}", "api/beta/organization/spend_limits/delete", "", "SpendLimitDeleteResponse", "", "", "", "", "", Auth::kAdmin, Kind::kDestructive, Page::kNone, Wire::kJson, false, false},
+ {Call::kSpendLimitsEffectiveList, "organization.spend_limits.effective.list", "GET", "/v1/organizations/spend_limits/effective", "api/beta/organization/spend_limits/effective/list", "EffectiveListParams", "BetaSpendSummary", "", "", "limit,page,period[],user_ids[]", "", "", Auth::kAdmin, Kind::kRead, Page::kCursor, Wire::kJson, false, false},
+ {Call::kSpendLimitsIncreaseRequestsApprove, "organization.spend_limits.increase_requests.approve", "POST", "/v1/organizations/spend_limit_increase_requests/{spend_limit_increase_request_id}/approve", "api/beta/organization/spend_limits/increase_requests/approve", "IncreaseRequestApproveParams", "IncreaseRequestApproveResponse", "amount,period,suppress_notification", "amount", "", "", "", Auth::kAdmin, Kind::kDestructive, Page::kNone, Wire::kJson, false, false},
+ {Call::kSpendLimitsIncreaseRequestsDeny, "organization.spend_limits.increase_requests.deny", "POST", "/v1/organizations/spend_limit_increase_requests/{spend_limit_increase_request_id}/deny", "api/beta/organization/spend_limits/increase_requests/deny", "IncreaseRequestDenyParams", "BetaSpendLimitIncreaseRequest", "suppress_notification", "", "", "", "", Auth::kAdmin, Kind::kDestructive, Page::kNone, Wire::kJson, false, false},
+ {Call::kSpendLimitsIncreaseRequestsList, "organization.spend_limits.increase_requests.list", "GET", "/v1/organizations/spend_limit_increase_requests", "api/beta/organization/spend_limits/increase_requests/list", "IncreaseRequestListParams", "BetaSpendLimitIncreaseRequest", "", "", "actor_ids[],limit,page,status[]", "", "", Auth::kAdmin, Kind::kRead, Page::kCursor, Wire::kJson, false, false},
+ {Call::kSpendLimitsIncreaseRequestsRetrieve, "organization.spend_limits.increase_requests.retrieve", "GET", "/v1/organizations/spend_limit_increase_requests/{spend_limit_increase_request_id}", "api/beta/organization/spend_limits/increase_requests/retrieve", "", "BetaSpendLimitIncreaseRequest", "", "", "", "", "", Auth::kAdmin, Kind::kRead, Page::kNone, Wire::kJson, false, false},
+ {Call::kSpendLimitsList, "organization.spend_limits.list", "GET", "/v1/organizations/spend_limits", "api/beta/organization/spend_limits/list", "SpendLimitListParams", "BetaSpendLimit", "", "", "limit,page,scope_type[],workspace_id", "", "spend-limit-reads-2026-09-26", Auth::kAdmin, Kind::kRead, Page::kCursor, Wire::kJson, true, false},
+ {Call::kSpendLimitsRetrieve, "organization.spend_limits.retrieve", "GET", "/v1/organizations/spend_limits/{spend_limit_id}", "api/beta/organization/spend_limits/retrieve", "", "BetaSpendLimit", "", "", "", "", "", Auth::kAdmin, Kind::kRead, Page::kNone, Wire::kJson, false, false},
+ {Call::kSpendLimitsSet, "organization.spend_limits.set", "POST", "/v1/organizations/spend_limits", "api/beta/organization/spend_limits/set", "SpendLimitSetParams", "BetaSpendLimit", "amount,scope,period", "amount,scope", "", "", "", Auth::kAdmin, Kind::kWrite, Page::kNone, Wire::kJson, false, false},
+ {Call::kTelemetryDestinationsCreate, "organization.telemetry_destinations.create", "POST", "/v1/organizations/telemetry_destinations", "api/beta/organization/telemetry_destinations/create", "TelemetryDestinationCreateParams", "BetaTelemetryDestination", "endpoint_url,workspaces,display_name,headers,traces", "endpoint_url,workspaces", "", "", "telemetry-destinations-2026-08-11", Auth::kAdmin, Kind::kWrite, Page::kNone, Wire::kJson, false, false},
+ {Call::kTelemetryDestinationsDelete, "organization.telemetry_destinations.delete", "DELETE", "/v1/organizations/telemetry_destinations/{destination_id}", "api/beta/organization/telemetry_destinations/delete", "", "BetaDeletedTelemetryDestination", "", "", "", "", "telemetry-destinations-2026-08-11", Auth::kAdmin, Kind::kDestructive, Page::kNone, Wire::kJson, false, false},
+ {Call::kTelemetryDestinationsList, "organization.telemetry_destinations.list", "GET", "/v1/organizations/telemetry_destinations", "api/beta/organization/telemetry_destinations/list", "TelemetryDestinationListParams", "BetaTelemetryDestination", "", "", "limit,page,workspace_ids[]", "", "telemetry-destinations-2026-08-11", Auth::kAdmin, Kind::kRead, Page::kCursor, Wire::kJson, false, false},
+ {Call::kTelemetryDestinationsRetrieve, "organization.telemetry_destinations.retrieve", "GET", "/v1/organizations/telemetry_destinations/{destination_id}", "api/beta/organization/telemetry_destinations/retrieve", "", "BetaTelemetryDestination", "", "", "", "", "telemetry-destinations-2026-08-11", Auth::kAdmin, Kind::kRead, Page::kNone, Wire::kJson, false, false},
+ {Call::kTelemetryDestinationsTest, "organization.telemetry_destinations.test", "POST", "/v1/organizations/telemetry_destinations/{destination_id}/test", "api/beta/organization/telemetry_destinations/test", "", "BetaTelemetryDestinationTestResponse", "", "", "", "", "telemetry-destinations-2026-08-11", Auth::kAdmin, Kind::kWrite, Page::kNone, Wire::kJson, false, false},
+ {Call::kTelemetryDestinationsUpdate, "organization.telemetry_destinations.update", "POST", "/v1/organizations/telemetry_destinations/{destination_id}", "api/beta/organization/telemetry_destinations/update", "TelemetryDestinationUpdateParams", "BetaTelemetryDestination", "display_name,endpoint_url,headers,state,traces,workspaces", "", "", "", "telemetry-destinations-2026-08-11", Auth::kAdmin, Kind::kWrite, Page::kNone, Wire::kJson, false, false},
+ {Call::kTelemetryDestinationsWorkspacesAdd, "organization.telemetry_destinations.workspaces.add", "POST", "/v1/organizations/telemetry_destinations/{destination_id}/workspaces/{workspace_id}", "api/beta/organization/telemetry_destinations/workspaces/add", "", "BetaTelemetryDestinationWorkspace", "", "", "", "", "telemetry-destinations-2026-08-11", Auth::kAdmin, Kind::kWrite, Page::kNone, Wire::kJson, false, false},
+ {Call::kTelemetryDestinationsWorkspacesList, "organization.telemetry_destinations.workspaces.list", "GET", "/v1/organizations/telemetry_destinations/{destination_id}/workspaces", "api/beta/organization/telemetry_destinations/workspaces/list", "WorkspaceListParams", "BetaTelemetryDestinationWorkspace", "", "", "limit,page", "", "telemetry-destinations-2026-08-11", Auth::kAdmin, Kind::kRead, Page::kCursor, Wire::kJson, false, false},
+ {Call::kTelemetryDestinationsWorkspacesRemove, "organization.telemetry_destinations.workspaces.remove", "DELETE", "/v1/organizations/telemetry_destinations/{destination_id}/workspaces/{workspace_id}", "api/beta/organization/telemetry_destinations/workspaces/remove", "", "BetaDeletedTelemetryDestinationWorkspace", "", "", "", "", "telemetry-destinations-2026-08-11", Auth::kAdmin, Kind::kDestructive, Page::kNone, Wire::kJson, false, false},
+ {Call::kUsageReportRetrieveClaudeCode, "organization.usage_report.retrieve_claude_code", "GET", "/v1/organizations/usage_report/claude_code", "api/beta/organization/usage_report/retrieve_claude_code", "", "BetaClaudeCodeUsageReport", "", "starting_at", "starting_at,limit,page", "", "", Auth::kAdmin, Kind::kRead, Page::kReport, Wire::kJson, false, true},
+ {Call::kUsageReportRetrieveMessages, "organization.usage_report.retrieve_messages", "GET", "/v1/organizations/usage_report/messages", "api/beta/organization/usage_report/retrieve_messages", "", "BetaMessagesUsageReport", "", "starting_at", "starting_at,account_ids[],api_key_ids[],bucket_width,context_window[],ending_at,group_by[],inference_geos[],limit,models[],page,service_account_ids[],service_tiers[],speeds[],workspace_ids[]", "", "", Auth::kAdmin, Kind::kRead, Page::kReport, Wire::kJson, false, true},
+ {Call::kUsersList, "organization.users.list", "GET", "/v1/organizations/users", "api/organization/users/list", "UserListParams", "BetaOrganizationUser", "", "", "after_id,before_id,email,limit,roles[]", "", "", Auth::kAdmin, Kind::kRead, Page::kIds, Wire::kJson, false, false},
+ {Call::kUsersRemove, "organization.users.remove", "DELETE", "/v1/organizations/users/{user_id}", "api/organization/users/remove", "", "UserRemoveResponse", "", "", "", "", "", Auth::kAdmin, Kind::kDestructive, Page::kNone, Wire::kJson, false, false},
+ {Call::kUsersRetrieve, "organization.users.retrieve", "GET", "/v1/organizations/users/{user_id}", "api/organization/users/retrieve", "", "BetaOrganizationUser", "", "", "", "", "", Auth::kAdmin, Kind::kRead, Page::kNone, Wire::kJson, false, false},
+ {Call::kUsersUpdate, "organization.users.update", "POST", "/v1/organizations/users/{user_id}", "api/organization/users/update", "UserUpdateParams", "BetaOrganizationUser", "role", "role", "", "", "", Auth::kAdmin, Kind::kWrite, Page::kNone, Wire::kJson, false, false},
+ {Call::kWebhooksCreate, "organization.webhooks.create", "POST", "/v1/organizations/webhooks", "api/beta/organization/webhooks/create", "WebhookCreateParams", "BetaNewOrganizationWebhookEndpoint", "enabled_events,url,description,name", "enabled_events,url", "", "", "webhooks-2026-10-07", Auth::kAdmin, Kind::kWrite, Page::kNone, Wire::kJson, false, false},
+ {Call::kWebhooksDelete, "organization.webhooks.delete", "DELETE", "/v1/organizations/webhooks/{webhook_endpoint_id}", "api/beta/organization/webhooks/delete", "", "BetaDeletedOrganizationWebhookEndpoint", "", "", "", "", "webhooks-2026-10-07", Auth::kAdmin, Kind::kDestructive, Page::kNone, Wire::kJson, false, false},
+ {Call::kWebhooksList, "organization.webhooks.list", "GET", "/v1/organizations/webhooks", "api/beta/organization/webhooks/list", "WebhookListParams", "BetaOrganizationWebhookEndpoint", "", "", "after_id,before_id,limit,order", "", "webhooks-2026-10-07", Auth::kAdmin, Kind::kRead, Page::kIds, Wire::kJson, false, false},
+ {Call::kWebhooksRegenerateSigningSecret, "organization.webhooks.regenerate_signing_secret", "POST", "/v1/organizations/webhooks/{webhook_endpoint_id}/regenerate_signing_secret", "api/beta/organization/webhooks/regenerate_signing_secret", "", "BetaOrganizationWebhookEndpointSigningSecret", "", "", "", "", "webhooks-2026-10-07", Auth::kAdmin, Kind::kDestructive, Page::kNone, Wire::kJson, false, false},
+ {Call::kWebhooksRetrieve, "organization.webhooks.retrieve", "GET", "/v1/organizations/webhooks/{webhook_endpoint_id}", "api/beta/organization/webhooks/retrieve", "", "BetaOrganizationWebhookEndpoint", "", "", "", "", "webhooks-2026-10-07", Auth::kAdmin, Kind::kRead, Page::kNone, Wire::kJson, false, false},
+ {Call::kWebhooksUpdate, "organization.webhooks.update", "POST", "/v1/organizations/webhooks/{webhook_endpoint_id}", "api/beta/organization/webhooks/update", "WebhookUpdateParams", "BetaOrganizationWebhookEndpoint", "description,enabled_events,name,state,url", "", "", "", "webhooks-2026-10-07", Auth::kAdmin, Kind::kWrite, Page::kNone, Wire::kJson, false, false},
+ {Call::kWorkspacesArchive, "organization.workspaces.archive", "POST", "/v1/organizations/workspaces/{workspace_id}/archive", "api/organization/workspaces/archive", "", "BetaWorkspace", "", "", "", "", "", Auth::kAdmin, Kind::kDestructive, Page::kNone, Wire::kJson, false, false},
+ {Call::kWorkspacesCreate, "organization.workspaces.create", "POST", "/v1/organizations/workspaces", "api/organization/workspaces/create", "WorkspaceCreateParams", "BetaWorkspace", "name,data_residency,display_color,external_key_id,tags", "name", "", "", "", Auth::kAdmin, Kind::kWrite, Page::kNone, Wire::kJson, false, false},
+ {Call::kWorkspacesList, "organization.workspaces.list", "GET", "/v1/organizations/workspaces", "api/organization/workspaces/list", "WorkspaceListParams", "BetaWorkspace", "", "", "after_id,before_id,include_archived,include_default,limit", "", "", Auth::kAdmin, Kind::kRead, Page::kIds, Wire::kJson, false, false},
+ {Call::kWorkspacesMembersAdd, "organization.workspaces.members.add", "POST", "/v1/organizations/workspaces/{workspace_id}/members", "api/organization/workspaces/members/add", "MemberAddParams", "BetaWorkspaceMember", "user_id,workspace_role", "user_id,workspace_role", "", "", "", Auth::kAdmin, Kind::kWrite, Page::kNone, Wire::kJson, false, false},
+ {Call::kWorkspacesMembersList, "organization.workspaces.members.list", "GET", "/v1/organizations/workspaces/{workspace_id}/members", "api/organization/workspaces/members/list", "MemberListParams", "BetaWorkspaceMember", "", "", "after_id,before_id,limit", "", "", Auth::kAdmin, Kind::kRead, Page::kIds, Wire::kJson, false, false},
+ {Call::kWorkspacesMembersRemove, "organization.workspaces.members.remove", "DELETE", "/v1/organizations/workspaces/{workspace_id}/members/{user_id}", "api/organization/workspaces/members/remove", "", "MemberRemoveResponse", "", "", "", "", "", Auth::kAdmin, Kind::kDestructive, Page::kNone, Wire::kJson, true, false},
+ {Call::kWorkspacesMembersRetrieve, "organization.workspaces.members.retrieve", "GET", "/v1/organizations/workspaces/{workspace_id}/members/{user_id}", "api/organization/workspaces/members/retrieve", "", "BetaWorkspaceMember", "", "", "", "", "", Auth::kAdmin, Kind::kRead, Page::kNone, Wire::kJson, true, false},
+ {Call::kWorkspacesMembersUpdate, "organization.workspaces.members.update", "POST", "/v1/organizations/workspaces/{workspace_id}/members/{user_id}", "api/organization/workspaces/members/update", "MemberUpdateParams", "BetaWorkspaceMember", "workspace_role", "workspace_role", "", "", "", Auth::kAdmin, Kind::kWrite, Page::kNone, Wire::kJson, true, false},
+ {Call::kWorkspacesRateLimitsList, "organization.workspaces.rate_limits.list", "GET", "/v1/organizations/workspaces/{workspace_id}/rate_limits", "api/organization/workspaces/rate_limits/list", "RateLimitListParams", "BetaWorkspaceRateLimit", "", "", "group_type,include_inherited,limit,page", "", "", Auth::kAdmin, Kind::kRead, Page::kCursor, Wire::kJson, false, false},
+ {Call::kWorkspacesRateLimitsUpdate, "organization.workspaces.rate_limits.update", "POST", "/v1/organizations/workspaces/{workspace_id}/rate_limits/{rate_limit_id}", "api/organization/workspaces/rate_limits/update", "RateLimitUpdateParams", "BetaWorkspaceRateLimit", "limits", "limits", "", "", "", Auth::kAdmin, Kind::kWrite, Page::kNone, Wire::kJson, true, false},
+ {Call::kWorkspacesRetrieve, "organization.workspaces.retrieve", "GET", "/v1/organizations/workspaces/{workspace_id}", "api/organization/workspaces/retrieve", "", "BetaWorkspace", "", "", "", "", "", Auth::kAdmin, Kind::kRead, Page::kNone, Wire::kJson, false, false},
+ {Call::kWorkspacesUpdate, "organization.workspaces.update", "POST", "/v1/organizations/workspaces/{workspace_id}", "api/organization/workspaces/update", "WorkspaceUpdateParams", "BetaWorkspace", "data_residency,display_color,external_key_id,name,tags", "", "", "", "", Auth::kAdmin, Kind::kWrite, Page::kNone, Wire::kJson, false, false},
+ {Call::kFederationIssuersArchive, "organization.federation.issuers.archive", "POST", "/v1/organizations/federation_issuers/{federation_issuer_id}/archive", "api/organization/federation/issuers/archive", "", "BetaFederationIssuer", "", "", "", "", "", Auth::kOAuth, Kind::kDestructive, Page::kNone, Wire::kJson, false, false},
+ {Call::kFederationIssuersCreate, "organization.federation.issuers.create", "POST", "/v1/organizations/federation_issuers", "api/organization/federation/issuers/create", "IssuerCreateParams", "BetaFederationIssuer", "issuer_url,name,check_jti,jwks,max_jwt_lifetime_seconds", "issuer_url,name", "", "", "", Auth::kOAuth, Kind::kWrite, Page::kNone, Wire::kJson, false, false},
+ {Call::kFederationIssuersList, "organization.federation.issuers.list", "GET", "/v1/organizations/federation_issuers", "api/organization/federation/issuers/list", "IssuerListParams", "BetaFederationIssuer", "", "", "include_archived,limit,page", "", "", Auth::kOAuth, Kind::kRead, Page::kCursor, Wire::kJson, false, false},
+ {Call::kFederationIssuersRetrieve, "organization.federation.issuers.retrieve", "GET", "/v1/organizations/federation_issuers/{federation_issuer_id}", "api/organization/federation/issuers/retrieve", "", "BetaFederationIssuer", "", "", "", "", "", Auth::kOAuth, Kind::kRead, Page::kNone, Wire::kJson, false, false},
+ {Call::kFederationIssuersUpdate, "organization.federation.issuers.update", "POST", "/v1/organizations/federation_issuers/{federation_issuer_id}", "api/organization/federation/issuers/update", "IssuerUpdateParams", "BetaFederationIssuer", "check_jti,issuer_url,jwks,jwks_polling_disabled,max_jwt_lifetime_seconds,name", "", "", "", "", Auth::kOAuth, Kind::kWrite, Page::kNone, Wire::kJson, false, false},
+ {Call::kFederationRulesArchive, "organization.federation.rules.archive", "POST", "/v1/organizations/federation_rules/{federation_rule_id}/archive", "api/organization/federation/rules/archive", "", "BetaFederationRule", "", "", "", "", "", Auth::kOAuth, Kind::kDestructive, Page::kNone, Wire::kJson, false, false},
+ {Call::kFederationRulesCreate, "organization.federation.rules.create", "POST", "/v1/organizations/federation_rules", "api/organization/federation/rules/create", "RuleCreateParams", "BetaFederationRule", "issuer_id,match,name,oauth_scope,target,applies_to_all_workspaces,attributes,description,token_lifetime_seconds,workspace_id", "issuer_id,match,name,oauth_scope,target", "", "", "", Auth::kOAuth, Kind::kWrite, Page::kNone, Wire::kJson, true, false},
+ {Call::kFederationRulesList, "organization.federation.rules.list", "GET", "/v1/organizations/federation_rules", "api/organization/federation/rules/list", "RuleListParams", "BetaFederationRule", "", "", "include_archived,issuer_id,limit,page", "", "", Auth::kOAuth, Kind::kRead, Page::kCursor, Wire::kJson, false, false},
+ {Call::kFederationRulesRetrieve, "organization.federation.rules.retrieve", "GET", "/v1/organizations/federation_rules/{federation_rule_id}", "api/organization/federation/rules/retrieve", "", "BetaFederationRule", "", "", "", "", "", Auth::kOAuth, Kind::kRead, Page::kNone, Wire::kJson, false, false},
+ {Call::kFederationRulesUpdate, "organization.federation.rules.update", "POST", "/v1/organizations/federation_rules/{federation_rule_id}", "api/organization/federation/rules/update", "RuleUpdateParams", "BetaFederationRule", "applies_to_all_workspaces,attributes,description,match,name,oauth_scope,target,token_lifetime_seconds,workspace_id", "", "", "", "", Auth::kOAuth, Kind::kWrite, Page::kNone, Wire::kJson, true, false},
+ {Call::kFederationRulesWorkspacesAdd, "organization.federation.rules.workspaces.add", "POST", "/v1/organizations/federation_rules/{federation_rule_id}/workspaces", "api/organization/federation/rules/workspaces/add", "WorkspaceAddParams", "BetaFederationRuleWorkspace", "workspace_id", "workspace_id", "", "", "", Auth::kOAuth, Kind::kWrite, Page::kNone, Wire::kJson, true, false},
+ {Call::kFederationRulesWorkspacesList, "organization.federation.rules.workspaces.list", "GET", "/v1/organizations/federation_rules/{federation_rule_id}/workspaces", "api/organization/federation/rules/workspaces/list", "WorkspaceListParams", "BetaFederationRuleWorkspace", "", "", "limit,page", "", "", Auth::kOAuth, Kind::kRead, Page::kCursor, Wire::kJson, false, false},
+ {Call::kFederationRulesWorkspacesRemove, "organization.federation.rules.workspaces.remove", "DELETE", "/v1/organizations/federation_rules/{federation_rule_id}/workspaces/{workspace_id}", "api/organization/federation/rules/workspaces/remove", "", "WorkspaceRemoveResponse", "", "", "", "", "", Auth::kOAuth, Kind::kDestructive, Page::kNone, Wire::kJson, false, false},
+ {Call::kServiceAccountsArchive, "organization.service_accounts.archive", "POST", "/v1/organizations/service_accounts/{service_account_id}/archive", "api/organization/service_accounts/archive", "", "BetaServiceAccount", "", "", "", "", "", Auth::kOAuth, Kind::kDestructive, Page::kNone, Wire::kJson, false, false},
+ {Call::kServiceAccountsCreate, "organization.service_accounts.create", "POST", "/v1/organizations/service_accounts", "api/organization/service_accounts/create", "ServiceAccountCreateParams", "BetaServiceAccount", "name,description,organization_role", "name", "", "", "", Auth::kOAuth, Kind::kWrite, Page::kNone, Wire::kJson, false, false},
+ {Call::kServiceAccountsList, "organization.service_accounts.list", "GET", "/v1/organizations/service_accounts", "api/organization/service_accounts/list", "ServiceAccountListParams", "BetaServiceAccount", "", "", "include_archived,limit,page", "", "", Auth::kOAuth, Kind::kRead, Page::kCursor, Wire::kJson, false, false},
+ {Call::kServiceAccountsRetrieve, "organization.service_accounts.retrieve", "GET", "/v1/organizations/service_accounts/{service_account_id}", "api/organization/service_accounts/retrieve", "", "BetaServiceAccount", "", "", "", "", "", Auth::kOAuth, Kind::kRead, Page::kNone, Wire::kJson, false, false},
+ {Call::kServiceAccountsUpdate, "organization.service_accounts.update", "POST", "/v1/organizations/service_accounts/{service_account_id}", "api/organization/service_accounts/update", "ServiceAccountUpdateParams", "BetaServiceAccount", "description,organization_role", "", "", "", "", Auth::kOAuth, Kind::kWrite, Page::kNone, Wire::kJson, false, false},
+ {Call::kServiceAccountsWorkspacesAdd, "organization.service_accounts.workspaces.add", "POST", "/v1/organizations/service_accounts/{service_account_id}/workspaces", "api/organization/service_accounts/workspaces/add", "WorkspaceAddParams", "BetaServiceAccountWorkspaceMember", "workspace_id,workspace_role", "workspace_id,workspace_role", "", "", "", Auth::kOAuth, Kind::kWrite, Page::kNone, Wire::kJson, true, false},
+ {Call::kServiceAccountsWorkspacesList, "organization.service_accounts.workspaces.list", "GET", "/v1/organizations/service_accounts/{service_account_id}/workspaces", "api/organization/service_accounts/workspaces/list", "WorkspaceListParams", "BetaServiceAccountWorkspaceMember", "", "", "limit,page", "", "", Auth::kOAuth, Kind::kRead, Page::kCursor, Wire::kJson, false, false},
+ {Call::kServiceAccountsWorkspacesRemove, "organization.service_accounts.workspaces.remove", "DELETE", "/v1/organizations/service_accounts/{service_account_id}/workspaces/{workspace_id}", "api/organization/service_accounts/workspaces/remove", "", "WorkspaceRemoveResponse", "", "", "", "", "", Auth::kOAuth, Kind::kDestructive, Page::kNone, Wire::kJson, false, false},
+ {Call::kWorkspacesServiceAccountsAdd, "organization.workspaces.service_accounts.add", "POST", "/v1/organizations/workspaces/{workspace_id}/service_accounts", "api/organization/workspaces/service_accounts/add", "ServiceAccountAddParams", "BetaServiceAccountWorkspaceMember", "service_account_id,workspace_role", "service_account_id,workspace_role", "", "", "", Auth::kOAuth, Kind::kWrite, Page::kNone, Wire::kJson, false, false},
+ {Call::kWorkspacesServiceAccountsList, "organization.workspaces.service_accounts.list", "GET", "/v1/organizations/workspaces/{workspace_id}/service_accounts", "api/organization/workspaces/service_accounts/list", "ServiceAccountListParams", "BetaServiceAccountWorkspaceMember", "", "", "limit,page", "", "", Auth::kOAuth, Kind::kRead, Page::kCursor, Wire::kJson, false, false},
+ {Call::kWorkspacesServiceAccountsRemove, "organization.workspaces.service_accounts.remove", "DELETE", "/v1/organizations/workspaces/{workspace_id}/service_accounts/{service_account_id}", "api/organization/workspaces/service_accounts/remove", "", "ServiceAccountRemoveResponse", "", "", "", "", "", Auth::kOAuth, Kind::kDestructive, Page::kNone, Wire::kJson, true, false},
+ {Call::kWorkspacesServiceAccountsRetrieve, "organization.workspaces.service_accounts.retrieve", "GET", "/v1/organizations/workspaces/{workspace_id}/service_accounts/{service_account_id}", "api/organization/workspaces/service_accounts/retrieve", "", "BetaServiceAccountWorkspaceMember", "", "", "", "", "", Auth::kOAuth, Kind::kRead, Page::kNone, Wire::kJson, true, false},
+ {Call::kWorkspacesServiceAccountsUpdate, "organization.workspaces.service_accounts.update", "POST", "/v1/organizations/workspaces/{workspace_id}/service_accounts/{service_account_id}", "api/organization/workspaces/service_accounts/update", "ServiceAccountUpdateParams", "BetaServiceAccountWorkspaceMember", "workspace_role", "workspace_role", "", "", "", Auth::kOAuth, Kind::kWrite, Page::kNone, Wire::kJson, true, false},
+ {Call::kAgentsArchive, "agents.archive", "POST", "/v1/agents/{agent_id}/archive", "api/beta/agents/archive", "", "BetaManagedAgentsAgent", "", "", "", "", "managed-agents-2026-04-01", Auth::kPlatform, Kind::kDestructive, Page::kNone, Wire::kJson, true, false},
+ {Call::kAgentsCreate, "agents.create", "POST", "/v1/agents", "api/beta/agents/create", "AgentCreateParams", "BetaManagedAgentsAgent", "model,name,description,execution_identity,mcp_servers,metadata,multiagent,skills,system,tools", "model,name", "", "", "managed-agents-2026-04-01", Auth::kPlatform, Kind::kWrite, Page::kNone, Wire::kJson, true, false},
+ {Call::kAgentsList, "agents.list", "GET", "/v1/agents", "api/beta/agents/list", "AgentListParams", "BetaManagedAgentsAgent", "", "", "created_at[gte],created_at[lte],include_archived,limit,page", "", "managed-agents-2026-04-01", Auth::kPlatform, Kind::kRead, Page::kCursor, Wire::kJson, true, false},
+ {Call::kAgentsRetrieve, "agents.retrieve", "GET", "/v1/agents/{agent_id}", "api/beta/agents/retrieve", "AgentRetrieveParams", "BetaManagedAgentsAgent", "", "", "version", "", "managed-agents-2026-04-01", Auth::kPlatform, Kind::kRead, Page::kNone, Wire::kJson, true, false},
+ {Call::kAgentsUpdate, "agents.update", "POST", "/v1/agents/{agent_id}", "api/beta/agents/update", "AgentUpdateParams", "BetaManagedAgentsAgent", "description,execution_identity,mcp_servers,metadata,model,multiagent,name,skills,system,tools,version", "", "", "", "managed-agents-2026-04-01", Auth::kPlatform, Kind::kWrite, Page::kNone, Wire::kJson, true, false},
+ {Call::kAgentsVersionsList, "agents.versions.list", "GET", "/v1/agents/{agent_id}/versions", "api/beta/agents/versions/list", "VersionListParams", "BetaManagedAgentsAgent", "", "", "limit,page", "", "managed-agents-2026-04-01", Auth::kPlatform, Kind::kRead, Page::kCursor, Wire::kJson, true, false},
+ {Call::kDeploymentRunsList, "deployment_runs.list", "GET", "/v1/deployment_runs", "api/beta/deployment_runs/list", "DeploymentRunListParams", "BetaManagedAgentsDeploymentRun", "", "", "created_at[gt],created_at[gte],created_at[lt],created_at[lte],deployment_id,has_error,limit,page,trigger_type", "", "managed-agents-2026-04-01", Auth::kPlatform, Kind::kRead, Page::kCursor, Wire::kJson, true, false},
+ {Call::kDeploymentRunsRetrieve, "deployment_runs.retrieve", "GET", "/v1/deployment_runs/{deployment_run_id}", "api/beta/deployment_runs/retrieve", "", "BetaManagedAgentsDeploymentRun", "", "", "", "", "managed-agents-2026-04-01", Auth::kPlatform, Kind::kRead, Page::kNone, Wire::kJson, true, false},
+ {Call::kDeploymentsArchive, "deployments.archive", "POST", "/v1/deployments/{deployment_id}/archive", "api/beta/deployments/archive", "", "BetaManagedAgentsDeployment", "", "", "", "", "managed-agents-2026-04-01", Auth::kPlatform, Kind::kDestructive, Page::kNone, Wire::kJson, true, false},
+ {Call::kDeploymentsCreate, "deployments.create", "POST", "/v1/deployments", "api/beta/deployments/create", "DeploymentCreateParams", "BetaManagedAgentsDeployment", "agent,environment_id,initial_events,name,budget,description,metadata,resources,schedule,vault_ids", "agent,environment_id,initial_events,name", "", "", "managed-agents-2026-04-01", Auth::kPlatform, Kind::kWrite, Page::kNone, Wire::kJson, true, false},
+ {Call::kDeploymentsList, "deployments.list", "GET", "/v1/deployments", "api/beta/deployments/list", "DeploymentListParams", "BetaManagedAgentsDeployment", "", "", "agent_id,created_at[gte],created_at[lte],include_archived,limit,page,status", "", "managed-agents-2026-04-01", Auth::kPlatform, Kind::kRead, Page::kCursor, Wire::kJson, true, false},
+ {Call::kDeploymentsPause, "deployments.pause", "POST", "/v1/deployments/{deployment_id}/pause", "api/beta/deployments/pause", "", "BetaManagedAgentsDeployment", "", "", "", "", "managed-agents-2026-04-01", Auth::kPlatform, Kind::kDestructive, Page::kNone, Wire::kJson, true, false},
+ {Call::kDeploymentsRetrieve, "deployments.retrieve", "GET", "/v1/deployments/{deployment_id}", "api/beta/deployments/retrieve", "", "BetaManagedAgentsDeployment", "", "", "", "", "managed-agents-2026-04-01", Auth::kPlatform, Kind::kRead, Page::kNone, Wire::kJson, true, false},
+ {Call::kDeploymentsRun, "deployments.run", "POST", "/v1/deployments/{deployment_id}/run", "api/beta/deployments/run", "", "BetaManagedAgentsDeploymentRun", "", "", "", "", "managed-agents-2026-04-01", Auth::kPlatform, Kind::kWrite, Page::kNone, Wire::kJson, true, false},
+ {Call::kDeploymentsUnpause, "deployments.unpause", "POST", "/v1/deployments/{deployment_id}/unpause", "api/beta/deployments/unpause", "", "BetaManagedAgentsDeployment", "", "", "", "", "managed-agents-2026-04-01", Auth::kPlatform, Kind::kWrite, Page::kNone, Wire::kJson, true, false},
+ {Call::kDeploymentsUpdate, "deployments.update", "POST", "/v1/deployments/{deployment_id}", "api/beta/deployments/update", "DeploymentUpdateParams", "BetaManagedAgentsDeployment", "agent,budget,description,environment_id,initial_events,metadata,name,resources,schedule,vault_ids", "", "", "", "managed-agents-2026-04-01", Auth::kPlatform, Kind::kWrite, Page::kNone, Wire::kJson, true, false},
+ {Call::kDreamsArchive, "dreams.archive", "POST", "/v1/dreams/{dream_id}/archive", "api/beta/dreams/archive", "", "BetaDream", "", "", "", "", "dreaming-2026-04-21", Auth::kPlatform, Kind::kDestructive, Page::kNone, Wire::kJson, true, false},
+ {Call::kDreamsCancel, "dreams.cancel", "POST", "/v1/dreams/{dream_id}/cancel", "api/beta/dreams/cancel", "", "BetaDream", "", "", "", "", "dreaming-2026-04-21", Auth::kPlatform, Kind::kDestructive, Page::kNone, Wire::kJson, true, false},
+ {Call::kDreamsCreate, "dreams.create", "POST", "/v1/dreams", "api/beta/dreams/create", "DreamCreateParams", "BetaDream", "inputs,model,instructions,output_behavior", "inputs,model", "", "", "dreaming-2026-04-21", Auth::kPlatform, Kind::kWrite, Page::kNone, Wire::kJson, true, false},
+ {Call::kDreamsList, "dreams.list", "GET", "/v1/dreams", "api/beta/dreams/list", "DreamListParams", "BetaDream", "", "", "created_at[gt],created_at[lt],include_archived,limit,page,statuses[]", "", "dreaming-2026-04-21", Auth::kPlatform, Kind::kRead, Page::kCursor, Wire::kJson, true, false},
+ {Call::kDreamsRetrieve, "dreams.retrieve", "GET", "/v1/dreams/{dream_id}", "api/beta/dreams/retrieve", "", "BetaDream", "", "", "", "", "dreaming-2026-04-21", Auth::kPlatform, Kind::kRead, Page::kNone, Wire::kJson, true, false},
+ {Call::kEnvironmentsArchive, "environments.archive", "POST", "/v1/environments/{environment_id}/archive", "api/beta/environments/archive", "", "BetaEnvironment", "", "", "", "", "managed-agents-2026-04-01", Auth::kPlatform, Kind::kDestructive, Page::kNone, Wire::kJson, true, false},
+ {Call::kEnvironmentsCreate, "environments.create", "POST", "/v1/environments", "api/beta/environments/create", "EnvironmentCreateParams", "BetaEnvironment", "name,config,description,metadata,scope", "name", "", "", "managed-agents-2026-04-01", Auth::kPlatform, Kind::kWrite, Page::kNone, Wire::kJson, true, false},
+ {Call::kEnvironmentsDelete, "environments.delete", "DELETE", "/v1/environments/{environment_id}", "api/beta/environments/delete", "", "BetaEnvironmentDeleteResponse", "", "", "", "", "managed-agents-2026-04-01", Auth::kPlatform, Kind::kDestructive, Page::kNone, Wire::kJson, true, false},
+ {Call::kEnvironmentsList, "environments.list", "GET", "/v1/environments", "api/beta/environments/list", "EnvironmentListParams", "BetaEnvironment", "", "", "include_archived,limit,page", "", "managed-agents-2026-04-01", Auth::kPlatform, Kind::kRead, Page::kCursor, Wire::kJson, true, false},
+ {Call::kEnvironmentsRetrieve, "environments.retrieve", "GET", "/v1/environments/{environment_id}", "api/beta/environments/retrieve", "", "BetaEnvironment", "", "", "", "", "managed-agents-2026-04-01", Auth::kPlatform, Kind::kRead, Page::kNone, Wire::kJson, true, false},
+ {Call::kEnvironmentsUpdate, "environments.update", "POST", "/v1/environments/{environment_id}", "api/beta/environments/update", "EnvironmentUpdateParams", "BetaEnvironment", "config,description,metadata,name,scope", "", "", "", "managed-agents-2026-04-01", Auth::kPlatform, Kind::kWrite, Page::kNone, Wire::kJson, true, false},
+ {Call::kEnvironmentsWorkAck, "environments.work.ack", "POST", "/v1/environments/{environment_id}/work/{work_id}/ack", "api/beta/environments/work/ack", "", "BetaSelfHostedWork", "", "", "", "", "managed-agents-2026-04-01", Auth::kPlatform, Kind::kWrite, Page::kNone, Wire::kJson, false, false},
+ {Call::kEnvironmentsWorkHeartbeat, "environments.work.heartbeat", "POST", "/v1/environments/{environment_id}/work/{work_id}/heartbeat", "api/beta/environments/work/heartbeat", "WorkHeartbeatParams", "BetaSelfHostedWorkHeartbeatResponse", "", "", "desired_ttl_seconds,expected_last_heartbeat", "", "managed-agents-2026-04-01", Auth::kPlatform, Kind::kWrite, Page::kNone, Wire::kJson, false, false},
+ {Call::kEnvironmentsWorkList, "environments.work.list", "GET", "/v1/environments/{environment_id}/work", "api/beta/environments/work/list", "WorkListParams", "BetaSelfHostedWork", "", "", "limit,page", "", "managed-agents-2026-04-01", Auth::kPlatform, Kind::kRead, Page::kCursor, Wire::kJson, false, false},
+ {Call::kEnvironmentsWorkPoll, "environments.work.poll", "GET", "/v1/environments/{environment_id}/work/poll", "api/beta/environments/work/poll", "WorkPollParams", "BetaSelfHostedWork", "", "", "block_ms,reclaim_older_than_ms", "anthropic_worker_id=Anthropic-Worker-ID", "managed-agents-2026-04-01", Auth::kPlatform, Kind::kRead, Page::kNone, Wire::kJson, false, false},
+ {Call::kEnvironmentsWorkRetrieve, "environments.work.retrieve", "GET", "/v1/environments/{environment_id}/work/{work_id}", "api/beta/environments/work/retrieve", "", "BetaSelfHostedWork", "", "", "", "", "managed-agents-2026-04-01", Auth::kPlatform, Kind::kRead, Page::kNone, Wire::kJson, true, false},
+ {Call::kEnvironmentsWorkStats, "environments.work.stats", "GET", "/v1/environments/{environment_id}/work/stats", "api/beta/environments/work/stats", "", "BetaSelfHostedWorkQueueStats", "", "", "", "", "managed-agents-2026-04-01", Auth::kPlatform, Kind::kRead, Page::kNone, Wire::kJson, true, false},
+ {Call::kEnvironmentsWorkStop, "environments.work.stop", "POST", "/v1/environments/{environment_id}/work/{work_id}/stop", "api/beta/environments/work/stop", "WorkStopParams", "BetaSelfHostedWork", "force", "", "", "", "managed-agents-2026-04-01", Auth::kPlatform, Kind::kDestructive, Page::kNone, Wire::kJson, true, false},
+ {Call::kEnvironmentsWorkUpdate, "environments.work.update", "POST", "/v1/environments/{environment_id}/work/{work_id}", "api/beta/environments/work/update", "WorkUpdateParams", "BetaSelfHostedWork", "metadata", "metadata", "", "", "managed-agents-2026-04-01", Auth::kPlatform, Kind::kWrite, Page::kNone, Wire::kJson, true, false},
+ {Call::kMemoryStoresArchive, "memory_stores.archive", "POST", "/v1/memory_stores/{memory_store_id}/archive", "api/beta/memory_stores/archive", "", "BetaManagedAgentsMemoryStore", "", "", "", "", "agent-memory-2026-07-22", Auth::kPlatform, Kind::kDestructive, Page::kNone, Wire::kJson, true, false},
+ {Call::kMemoryStoresCreate, "memory_stores.create", "POST", "/v1/memory_stores", "api/beta/memory_stores/create", "MemoryStoreCreateParams", "BetaManagedAgentsMemoryStore", "name,description,metadata", "name", "", "", "agent-memory-2026-07-22", Auth::kPlatform, Kind::kWrite, Page::kNone, Wire::kJson, true, false},
+ {Call::kMemoryStoresDelete, "memory_stores.delete", "DELETE", "/v1/memory_stores/{memory_store_id}", "api/beta/memory_stores/delete", "", "BetaManagedAgentsDeletedMemoryStore", "", "", "", "", "agent-memory-2026-07-22", Auth::kPlatform, Kind::kDestructive, Page::kNone, Wire::kJson, true, false},
+ {Call::kMemoryStoresList, "memory_stores.list", "GET", "/v1/memory_stores", "api/beta/memory_stores/list", "MemoryStoreListParams", "BetaManagedAgentsMemoryStore", "", "", "created_at[gte],created_at[lte],include_archived,limit,page", "", "agent-memory-2026-07-22", Auth::kPlatform, Kind::kRead, Page::kCursor, Wire::kJson, true, false},
+ {Call::kMemoryStoresMemoriesCreate, "memory_stores.memories.create", "POST", "/v1/memory_stores/{memory_store_id}/memories", "api/beta/memory_stores/memories/create", "MemoryCreateParams", "BetaManagedAgentsMemory", "content,path", "content,path", "view", "", "agent-memory-2026-07-22", Auth::kPlatform, Kind::kWrite, Page::kNone, Wire::kJson, true, false},
+ {Call::kMemoryStoresMemoriesDelete, "memory_stores.memories.delete", "DELETE", "/v1/memory_stores/{memory_store_id}/memories/{memory_id}", "api/beta/memory_stores/memories/delete", "MemoryDeleteParams", "BetaManagedAgentsDeletedMemory", "", "", "expected_content_sha256", "", "agent-memory-2026-07-22", Auth::kPlatform, Kind::kDestructive, Page::kNone, Wire::kJson, true, false},
+ {Call::kMemoryStoresMemoriesList, "memory_stores.memories.list", "GET", "/v1/memory_stores/{memory_store_id}/memories", "api/beta/memory_stores/memories/list", "MemoryListParams", "BetaManagedAgentsMemoryListItem", "", "", "depth,limit,page,path_prefix,view", "", "agent-memory-2026-07-22", Auth::kPlatform, Kind::kRead, Page::kCursor, Wire::kJson, true, false},
+ {Call::kMemoryStoresMemoriesRetrieve, "memory_stores.memories.retrieve", "GET", "/v1/memory_stores/{memory_store_id}/memories/{memory_id}", "api/beta/memory_stores/memories/retrieve", "MemoryRetrieveParams", "BetaManagedAgentsMemory", "", "", "view", "", "agent-memory-2026-07-22", Auth::kPlatform, Kind::kRead, Page::kNone, Wire::kJson, true, false},
+ {Call::kMemoryStoresMemoriesUpdate, "memory_stores.memories.update", "POST", "/v1/memory_stores/{memory_store_id}/memories/{memory_id}", "api/beta/memory_stores/memories/update", "MemoryUpdateParams", "BetaManagedAgentsMemory", "content,path,precondition", "", "view", "", "agent-memory-2026-07-22", Auth::kPlatform, Kind::kWrite, Page::kNone, Wire::kJson, true, false},
+ {Call::kMemoryStoresMemoryVersionsList, "memory_stores.memory_versions.list", "GET", "/v1/memory_stores/{memory_store_id}/memory_versions", "api/beta/memory_stores/memory_versions/list", "MemoryVersionListParams", "BetaManagedAgentsMemoryVersion", "", "", "api_key_id,created_at[gte],created_at[lte],limit,memory_id,operation,page,service_account_id,session_id,view", "", "agent-memory-2026-07-22", Auth::kPlatform, Kind::kRead, Page::kCursor, Wire::kJson, true, false},
+ {Call::kMemoryStoresMemoryVersionsRedact, "memory_stores.memory_versions.redact", "POST", "/v1/memory_stores/{memory_store_id}/memory_versions/{memory_version_id}/redact", "api/beta/memory_stores/memory_versions/redact", "", "BetaManagedAgentsMemoryVersion", "", "", "", "", "agent-memory-2026-07-22", Auth::kPlatform, Kind::kDestructive, Page::kNone, Wire::kJson, true, false},
+ {Call::kMemoryStoresMemoryVersionsRetrieve, "memory_stores.memory_versions.retrieve", "GET", "/v1/memory_stores/{memory_store_id}/memory_versions/{memory_version_id}", "api/beta/memory_stores/memory_versions/retrieve", "MemoryVersionRetrieveParams", "BetaManagedAgentsMemoryVersion", "", "", "view", "", "agent-memory-2026-07-22", Auth::kPlatform, Kind::kRead, Page::kNone, Wire::kJson, true, false},
+ {Call::kMemoryStoresRetrieve, "memory_stores.retrieve", "GET", "/v1/memory_stores/{memory_store_id}", "api/beta/memory_stores/retrieve", "", "BetaManagedAgentsMemoryStore", "", "", "", "", "agent-memory-2026-07-22", Auth::kPlatform, Kind::kRead, Page::kNone, Wire::kJson, true, false},
+ {Call::kMemoryStoresUpdate, "memory_stores.update", "POST", "/v1/memory_stores/{memory_store_id}", "api/beta/memory_stores/update", "MemoryStoreUpdateParams", "BetaManagedAgentsMemoryStore", "description,metadata,name", "", "", "", "agent-memory-2026-07-22", Auth::kPlatform, Kind::kWrite, Page::kNone, Wire::kJson, true, false},
+ {Call::kSessionsArchive, "sessions.archive", "POST", "/v1/sessions/{session_id}/archive", "api/beta/sessions/archive", "", "BetaManagedAgentsSession", "", "", "", "", "managed-agents-2026-04-01", Auth::kPlatform, Kind::kDestructive, Page::kNone, Wire::kJson, true, false},
+ {Call::kSessionsCreate, "sessions.create", "POST", "/v1/sessions", "api/beta/sessions/create", "SessionCreateParams", "BetaManagedAgentsSession", "agent,environment_id,budget,initial_events,metadata,resources,title,vault_ids", "agent,environment_id", "", "", "managed-agents-2026-04-01", Auth::kPlatform, Kind::kWrite, Page::kNone, Wire::kJson, true, false},
+ {Call::kSessionsDelete, "sessions.delete", "DELETE", "/v1/sessions/{session_id}", "api/beta/sessions/delete", "", "BetaManagedAgentsDeletedSession", "", "", "", "", "managed-agents-2026-04-01", Auth::kPlatform, Kind::kDestructive, Page::kNone, Wire::kJson, true, false},
+ {Call::kSessionsEventsList, "sessions.events.list", "GET", "/v1/sessions/{session_id}/events", "api/beta/sessions/events/list", "EventListParams", "BetaManagedAgentsSessionEvent", "", "", "created_at[gt],created_at[gte],created_at[lt],created_at[lte],limit,order,page,types[]", "", "managed-agents-2026-04-01", Auth::kPlatform, Kind::kRead, Page::kCursor, Wire::kJson, true, false},
+ {Call::kSessionsEventsSend, "sessions.events.send", "POST", "/v1/sessions/{session_id}/events", "api/beta/sessions/events/send", "EventSendParams", "BetaManagedAgentsSendSessionEvents", "events", "events", "", "", "managed-agents-2026-04-01", Auth::kPlatform, Kind::kWrite, Page::kNone, Wire::kJson, true, false},
+ {Call::kSessionsEventsStream, "sessions.events.stream", "GET", "/v1/sessions/{session_id}/events/stream", "api/beta/sessions/events/stream", "EventStreamParams", "BetaManagedAgentsStreamSessionEvents", "", "", "event_deltas[]", "", "managed-agents-2026-04-01", Auth::kPlatform, Kind::kRead, Page::kNone, Wire::kSse, true, false},
+ {Call::kSessionsList, "sessions.list", "GET", "/v1/sessions", "api/beta/sessions/list", "SessionListParams", "BetaManagedAgentsSession", "", "", "agent_id,agent_version,created_at[gt],created_at[gte],created_at[lt],created_at[lte],deployment_id,include_archived,limit,memory_store_id,order,page,statuses[]", "", "managed-agents-2026-04-01", Auth::kPlatform, Kind::kRead, Page::kBidirectional, Wire::kJson, true, false},
+ {Call::kSessionsResourcesAdd, "sessions.resources.add", "POST", "/v1/sessions/{session_id}/resources", "api/beta/sessions/resources/add", "ResourceAddParams", "BetaManagedAgentsFileResource", "file_id,type,mount_path", "file_id,type", "", "", "managed-agents-2026-04-01", Auth::kPlatform, Kind::kWrite, Page::kNone, Wire::kJson, true, false},
+ {Call::kSessionsResourcesDelete, "sessions.resources.delete", "DELETE", "/v1/sessions/{session_id}/resources/{resource_id}", "api/beta/sessions/resources/delete", "", "BetaManagedAgentsDeleteSessionResource", "", "", "", "", "managed-agents-2026-04-01", Auth::kPlatform, Kind::kDestructive, Page::kNone, Wire::kJson, true, false},
+ {Call::kSessionsResourcesList, "sessions.resources.list", "GET", "/v1/sessions/{session_id}/resources", "api/beta/sessions/resources/list", "ResourceListParams", "BetaManagedAgentsSessionResource", "", "", "limit,page", "", "managed-agents-2026-04-01", Auth::kPlatform, Kind::kRead, Page::kCursor, Wire::kJson, true, false},
+ {Call::kSessionsResourcesRetrieve, "sessions.resources.retrieve", "GET", "/v1/sessions/{session_id}/resources/{resource_id}", "api/beta/sessions/resources/retrieve", "", "ResourceRetrieveResponse", "", "", "", "", "managed-agents-2026-04-01", Auth::kPlatform, Kind::kRead, Page::kNone, Wire::kJson, true, false},
+ {Call::kSessionsResourcesUpdate, "sessions.resources.update", "POST", "/v1/sessions/{session_id}/resources/{resource_id}", "api/beta/sessions/resources/update", "ResourceUpdateParams", "ResourceUpdateResponse", "authorization_token", "authorization_token", "", "", "managed-agents-2026-04-01", Auth::kPlatform, Kind::kWrite, Page::kNone, Wire::kJson, true, false},
+ {Call::kSessionsRetrieve, "sessions.retrieve", "GET", "/v1/sessions/{session_id}", "api/beta/sessions/retrieve", "", "BetaManagedAgentsSession", "", "", "", "", "managed-agents-2026-04-01", Auth::kPlatform, Kind::kRead, Page::kNone, Wire::kJson, true, false},
+ {Call::kSessionsThreadsArchive, "sessions.threads.archive", "POST", "/v1/sessions/{session_id}/threads/{thread_id}/archive", "api/beta/sessions/threads/archive", "", "BetaManagedAgentsSessionThread", "", "", "", "", "managed-agents-2026-04-01", Auth::kPlatform, Kind::kDestructive, Page::kNone, Wire::kJson, true, false},
+ {Call::kSessionsThreadsEventsList, "sessions.threads.events.list", "GET", "/v1/sessions/{session_id}/threads/{thread_id}/events", "api/beta/sessions/threads/events/list", "EventListParams", "BetaManagedAgentsSessionEvent", "", "", "limit,page", "", "managed-agents-2026-04-01", Auth::kPlatform, Kind::kRead, Page::kCursor, Wire::kJson, true, false},
+ {Call::kSessionsThreadsEventsStream, "sessions.threads.events.stream", "GET", "/v1/sessions/{session_id}/threads/{thread_id}/stream", "api/beta/sessions/threads/events/stream", "EventStreamParams", "BetaManagedAgentsStreamSessionThreadEvents", "", "", "event_deltas[]", "", "managed-agents-2026-04-01", Auth::kPlatform, Kind::kRead, Page::kNone, Wire::kSse, true, false},
+ {Call::kSessionsThreadsList, "sessions.threads.list", "GET", "/v1/sessions/{session_id}/threads", "api/beta/sessions/threads/list", "ThreadListParams", "BetaManagedAgentsSessionThread", "", "", "limit,page,statuses[]", "", "managed-agents-2026-04-01", Auth::kPlatform, Kind::kRead, Page::kCursor, Wire::kJson, true, false},
+ {Call::kSessionsThreadsRetrieve, "sessions.threads.retrieve", "GET", "/v1/sessions/{session_id}/threads/{thread_id}", "api/beta/sessions/threads/retrieve", "", "BetaManagedAgentsSessionThread", "", "", "", "", "managed-agents-2026-04-01", Auth::kPlatform, Kind::kRead, Page::kNone, Wire::kJson, true, false},
+ {Call::kSessionsUpdate, "sessions.update", "POST", "/v1/sessions/{session_id}", "api/beta/sessions/update", "SessionUpdateParams", "BetaManagedAgentsSession", "agent,budget,metadata,title,vault_ids", "", "", "", "managed-agents-2026-04-01", Auth::kPlatform, Kind::kWrite, Page::kNone, Wire::kJson, true, false},
+ {Call::kTunnelsArchive, "tunnels.archive", "POST", "/v1/tunnels/{tunnel_id}/archive", "api/beta/tunnels/archive", "", "BetaTunnel", "", "", "", "", "mcp-tunnels-2026-06-22", Auth::kPlatform, Kind::kDestructive, Page::kNone, Wire::kJson, true, false},
+ {Call::kTunnelsCertificatesArchive, "tunnels.certificates.archive", "POST", "/v1/tunnels/{tunnel_id}/certificates/{certificate_id}/archive", "api/beta/tunnels/certificates/archive", "", "BetaTunnelCertificate", "", "", "", "", "mcp-tunnels-2026-06-22", Auth::kPlatform, Kind::kDestructive, Page::kNone, Wire::kJson, true, false},
+ {Call::kTunnelsCertificatesCreate, "tunnels.certificates.create", "POST", "/v1/tunnels/{tunnel_id}/certificates", "api/beta/tunnels/certificates/create", "CertificateCreateParams", "BetaTunnelCertificate", "ca_certificate_pem", "ca_certificate_pem", "", "", "mcp-tunnels-2026-06-22", Auth::kPlatform, Kind::kWrite, Page::kNone, Wire::kJson, true, false},
+ {Call::kTunnelsCertificatesList, "tunnels.certificates.list", "GET", "/v1/tunnels/{tunnel_id}/certificates", "api/beta/tunnels/certificates/list", "CertificateListParams", "BetaTunnelCertificate", "", "", "include_archived,limit,page", "", "mcp-tunnels-2026-06-22", Auth::kPlatform, Kind::kRead, Page::kCursor, Wire::kJson, true, false},
+ {Call::kTunnelsCertificatesRetrieve, "tunnels.certificates.retrieve", "GET", "/v1/tunnels/{tunnel_id}/certificates/{certificate_id}", "api/beta/tunnels/certificates/retrieve", "", "BetaTunnelCertificate", "", "", "", "", "mcp-tunnels-2026-06-22", Auth::kPlatform, Kind::kRead, Page::kNone, Wire::kJson, true, false},
+ {Call::kTunnelsCreate, "tunnels.create", "POST", "/v1/tunnels", "api/beta/tunnels/create", "TunnelCreateParams", "BetaTunnel", "display_name", "", "", "", "mcp-tunnels-2026-06-22", Auth::kPlatform, Kind::kWrite, Page::kNone, Wire::kJson, true, false},
+ {Call::kTunnelsList, "tunnels.list", "GET", "/v1/tunnels", "api/beta/tunnels/list", "TunnelListParams", "BetaTunnel", "", "", "include_archived,limit,page", "", "mcp-tunnels-2026-06-22", Auth::kPlatform, Kind::kRead, Page::kCursor, Wire::kJson, true, false},
+ {Call::kTunnelsRetrieve, "tunnels.retrieve", "GET", "/v1/tunnels/{tunnel_id}", "api/beta/tunnels/retrieve", "", "BetaTunnel", "", "", "", "", "mcp-tunnels-2026-06-22", Auth::kPlatform, Kind::kRead, Page::kNone, Wire::kJson, true, false},
+ {Call::kTunnelsRevealToken, "tunnels.reveal_token", "POST", "/v1/tunnels/{tunnel_id}/reveal_token", "api/beta/tunnels/reveal_token", "", "BetaTunnelToken", "", "", "", "", "mcp-tunnels-2026-06-22", Auth::kPlatform, Kind::kWrite, Page::kNone, Wire::kJson, true, false},
+ {Call::kTunnelsRotateToken, "tunnels.rotate_token", "POST", "/v1/tunnels/{tunnel_id}/rotate_token", "api/beta/tunnels/rotate_token", "TunnelRotateTokenParams", "BetaTunnelToken", "reason", "", "", "", "mcp-tunnels-2026-06-22", Auth::kPlatform, Kind::kDestructive, Page::kNone, Wire::kJson, true, false},
+ {Call::kUserProfilesActionUrlsCreate, "user_profiles.action_urls.create", "POST", "/v1/user_profiles/{user_profile_id}/action_urls", "api/user_profiles/action_urls/create", "ActionUrlCreateParams", "UserProfileActionURL", "action", "action", "", "", "", Auth::kPlatform, Kind::kWrite, Page::kNone, Wire::kJson, true, false},
+ {Call::kUserProfilesActionUrlsCreateBeta, "user_profiles.action_urls.createbeta", "POST", "/v1/user_profiles/{user_profile_id}/action_urls", "api/beta/user_profiles/action_urls/create", "ActionUrlCreateParams", "BetaUserProfileActionURL", "action", "action", "", "", "user-profiles-2026-08-18", Auth::kPlatform, Kind::kWrite, Page::kNone, Wire::kJson, true, false},
+ {Call::kUserProfilesCreate, "user_profiles.create", "POST", "/v1/user_profiles", "api/user_profiles/create", "UserProfileCreateParams", "UserProfile", "access_type,external_user_details,metadata,name", "", "", "", "", Auth::kPlatform, Kind::kWrite, Page::kNone, Wire::kJson, true, false},
+ {Call::kUserProfilesCreateBeta, "user_profiles.createbeta", "POST", "/v1/user_profiles", "api/beta/user_profiles/create", "UserProfileCreateParams", "BetaUserProfile", "access_type,external_id,external_user_details,external_user_onboarded_at,metadata,name", "", "", "", "user-profiles-2026-08-18", Auth::kPlatform, Kind::kWrite, Page::kNone, Wire::kJson, true, false},
+ {Call::kUserProfilesCreateEnrollmentUrl, "user_profiles.create_enrollment_url", "POST", "/v1/user_profiles/{user_profile_id}/enrollment_url", "api/beta/user_profiles/create_enrollment_url", "", "BetaUserProfileEnrollmentURL", "", "", "", "", "user-profiles-2026-08-18", Auth::kPlatform, Kind::kWrite, Page::kNone, Wire::kJson, true, false},
+ {Call::kUserProfilesDelete, "user_profiles.delete", "DELETE", "/v1/user_profiles/{user_profile_id}", "api/user_profiles/delete", "", "DeletedUserProfile", "", "", "", "", "", Auth::kPlatform, Kind::kDestructive, Page::kNone, Wire::kJson, true, false},
+ {Call::kUserProfilesDeleteBeta, "user_profiles.deletebeta", "DELETE", "/v1/user_profiles/{user_profile_id}", "api/beta/user_profiles/delete", "", "BetaDeletedUserProfile", "", "", "", "", "user-profiles-2026-08-18", Auth::kPlatform, Kind::kDestructive, Page::kNone, Wire::kJson, true, false},
+ {Call::kUserProfilesList, "user_profiles.list", "GET", "/v1/user_profiles", "api/user_profiles/list", "UserProfileListParams", "UserProfile", "", "", "enforcement_status[],limit,order,order_by,page", "", "", Auth::kPlatform, Kind::kRead, Page::kCursor, Wire::kJson, true, false},
+ {Call::kUserProfilesListBeta, "user_profiles.listbeta", "GET", "/v1/user_profiles", "api/beta/user_profiles/list", "UserProfileListParams", "BetaUserProfile", "", "", "limit,order,order_by,page", "", "user-profiles-2026-08-18", Auth::kPlatform, Kind::kRead, Page::kCursor, Wire::kJson, true, false},
+ {Call::kUserProfilesRetrieve, "user_profiles.retrieve", "GET", "/v1/user_profiles/{user_profile_id}", "api/user_profiles/retrieve", "", "UserProfile", "", "", "", "", "", Auth::kPlatform, Kind::kRead, Page::kNone, Wire::kJson, true, false},
+ {Call::kUserProfilesRetrieveBeta, "user_profiles.retrievebeta", "GET", "/v1/user_profiles/{user_profile_id}", "api/beta/user_profiles/retrieve", "", "BetaUserProfile", "", "", "", "", "user-profiles-2026-08-18", Auth::kPlatform, Kind::kRead, Page::kNone, Wire::kJson, true, false},
+ {Call::kUserProfilesUpdate, "user_profiles.update", "POST", "/v1/user_profiles/{user_profile_id}", "api/user_profiles/update", "UserProfileUpdateParams", "UserProfile", "access_type,external_user_details,metadata,name", "", "", "", "", Auth::kPlatform, Kind::kWrite, Page::kNone, Wire::kJson, true, false},
+ {Call::kUserProfilesUpdateBeta, "user_profiles.updatebeta", "POST", "/v1/user_profiles/{user_profile_id}", "api/beta/user_profiles/update", "UserProfileUpdateParams", "BetaUserProfile", "access_type,external_id,external_user_details,external_user_onboarded_at,metadata,name", "", "", "", "user-profiles-2026-08-18", Auth::kPlatform, Kind::kWrite, Page::kNone, Wire::kJson, true, false},
+ {Call::kVaultsArchive, "vaults.archive", "POST", "/v1/vaults/{vault_id}/archive", "api/beta/vaults/archive", "", "BetaManagedAgentsVault", "", "", "", "", "managed-agents-2026-04-01", Auth::kPlatform, Kind::kDestructive, Page::kNone, Wire::kJson, true, false},
+ {Call::kVaultsCreate, "vaults.create", "POST", "/v1/vaults", "api/beta/vaults/create", "VaultCreateParams", "BetaManagedAgentsVault", "display_name,metadata", "display_name", "", "", "managed-agents-2026-04-01", Auth::kPlatform, Kind::kWrite, Page::kNone, Wire::kJson, true, false},
+ {Call::kVaultsCredentialsArchive, "vaults.credentials.archive", "POST", "/v1/vaults/{vault_id}/credentials/{credential_id}/archive", "api/beta/vaults/credentials/archive", "", "BetaManagedAgentsCredential", "", "", "", "", "managed-agents-2026-04-01", Auth::kPlatform, Kind::kDestructive, Page::kNone, Wire::kJson, true, false},
+ {Call::kVaultsCredentialsCreate, "vaults.credentials.create", "POST", "/v1/vaults/{vault_id}/credentials", "api/beta/vaults/credentials/create", "CredentialCreateParams", "BetaManagedAgentsCredential", "auth,display_name,metadata", "auth", "", "", "managed-agents-2026-04-01", Auth::kPlatform, Kind::kWrite, Page::kNone, Wire::kJson, true, false},
+ {Call::kVaultsCredentialsDelete, "vaults.credentials.delete", "DELETE", "/v1/vaults/{vault_id}/credentials/{credential_id}", "api/beta/vaults/credentials/delete", "", "BetaManagedAgentsDeletedCredential", "", "", "", "", "managed-agents-2026-04-01", Auth::kPlatform, Kind::kDestructive, Page::kNone, Wire::kJson, true, false},
+ {Call::kVaultsCredentialsList, "vaults.credentials.list", "GET", "/v1/vaults/{vault_id}/credentials", "api/beta/vaults/credentials/list", "CredentialListParams", "BetaManagedAgentsCredential", "", "", "include_archived,limit,page", "", "managed-agents-2026-04-01", Auth::kPlatform, Kind::kRead, Page::kCursor, Wire::kJson, true, false},
+ {Call::kVaultsCredentialsMcpOauthValidate, "vaults.credentials.mcp_oauth_validate", "POST", "/v1/vaults/{vault_id}/credentials/{credential_id}/mcp_oauth_validate", "api/beta/vaults/credentials/mcp_oauth_validate", "", "BetaManagedAgentsCredentialValidation", "", "", "", "", "managed-agents-2026-04-01", Auth::kPlatform, Kind::kWrite, Page::kNone, Wire::kJson, true, false},
+ {Call::kVaultsCredentialsRetrieve, "vaults.credentials.retrieve", "GET", "/v1/vaults/{vault_id}/credentials/{credential_id}", "api/beta/vaults/credentials/retrieve", "", "BetaManagedAgentsCredential", "", "", "", "", "managed-agents-2026-04-01", Auth::kPlatform, Kind::kRead, Page::kNone, Wire::kJson, true, false},
+ {Call::kVaultsCredentialsUpdate, "vaults.credentials.update", "POST", "/v1/vaults/{vault_id}/credentials/{credential_id}", "api/beta/vaults/credentials/update", "CredentialUpdateParams", "BetaManagedAgentsCredential", "auth,display_name,metadata", "", "", "", "managed-agents-2026-04-01", Auth::kPlatform, Kind::kWrite, Page::kNone, Wire::kJson, true, false},
+ {Call::kVaultsDelete, "vaults.delete", "DELETE", "/v1/vaults/{vault_id}", "api/beta/vaults/delete", "", "BetaManagedAgentsDeletedVault", "", "", "", "", "managed-agents-2026-04-01", Auth::kPlatform, Kind::kDestructive, Page::kNone, Wire::kJson, true, false},
+ {Call::kVaultsList, "vaults.list", "GET", "/v1/vaults", "api/beta/vaults/list", "VaultListParams", "BetaManagedAgentsVault", "", "", "include_archived,limit,page", "", "managed-agents-2026-04-01", Auth::kPlatform, Kind::kRead, Page::kCursor, Wire::kJson, true, false},
+ {Call::kVaultsRetrieve, "vaults.retrieve", "GET", "/v1/vaults/{vault_id}", "api/beta/vaults/retrieve", "", "BetaManagedAgentsVault", "", "", "", "", "managed-agents-2026-04-01", Auth::kPlatform, Kind::kRead, Page::kNone, Wire::kJson, true, false},
+ {Call::kVaultsUpdate, "vaults.update", "POST", "/v1/vaults/{vault_id}", "api/beta/vaults/update", "VaultUpdateParams", "BetaManagedAgentsVault", "display_name,metadata", "", "", "", "managed-agents-2026-04-01", Auth::kPlatform, Kind::kWrite, Page::kNone, Wire::kJson, true, false},
+};
+// CALLS-END
+
+std::size_t call_count() { return sizeof(kCalls) / sizeof(kCalls[0]); }
+
+const CallSpec& spec_at(std::size_t index) {
+ if (index >= call_count()) throw std::out_of_range("call index");
+ return kCalls[index];
+}
+
+const CallSpec& spec_of(Call call) {
+ for (const CallSpec& s : kCalls)
+ if (s.call == call) return s;
+ throw std::out_of_range("unknown call");
+}
+
+clients::Method method_of(Call call) {
+ const std::string m = spec_of(call).http;
+ if (m == "GET") return clients::Method::kGet;
+ if (m == "POST") return clients::Method::kPost;
+ if (m == "DELETE") return clients::Method::kDelete;
+ if (m == "PATCH") return clients::Method::kPatch;
+ return clients::Method::kPut;
+}
+
+} // namespace molo::anthropic::admin
diff --git a/src/anthropic/admin/calls.h b/src/anthropic/admin/calls.h
new file mode 100644
index 0000000..baf3ab9
--- /dev/null
+++ b/src/anthropic/admin/calls.h
@@ -0,0 +1,310 @@
+// GENERATED by src/anthropic/admin/tools/check_spec.py --emit. Do not edit by hand:
+// the table is verified against the SDK source and the reference pages.
+#pragma once
+
+// The ONE table of REST calls this package makes. Every row is checked by
+// tools/check_spec.py against the official SDK source and the API reference.
+// Code builds every URL from this table, never from a literal.
+
+#include
+
+#include "clients/request.h"
+
+namespace molo::anthropic::admin {
+
+enum class Call {
+ kAnalyticsAppsChatProjectsList,
+ kAnalyticsArtifactsList,
+ kAnalyticsConnectorsList,
+ kAnalyticsCostList,
+ kAnalyticsCostReportList,
+ kAnalyticsPluginsList,
+ kAnalyticsSkillsList,
+ kAnalyticsSummariesList,
+ kAnalyticsUsageList,
+ kAnalyticsUsageReportList,
+ kAnalyticsUserCostReportList,
+ kAnalyticsUserUsageReportList,
+ kAnalyticsUsersList,
+ kApiKeysList,
+ kApiKeysRetrieve,
+ kApiKeysUpdate,
+ kClaudeTagBundlesList,
+ kClaudeTagBundlesRetrieve,
+ kClaudeTagBundlesTargetsCreate,
+ kClaudeTagBundlesTargetsDelete,
+ kClaudeTagBundlesTargetsList,
+ kClaudeTagBundlesTargetsRetrieve,
+ kClaudeTagSlackChannelsCreate,
+ kClaudeTagSlackChannelsDelete,
+ kClaudeTagSlackChannelsList,
+ kClaudeTagSlackChannelsRetrieve,
+ kClaudeTagSlackChannelsUpdate,
+ kClaudeTagSlackWorkspacesList,
+ kClaudeTagSlackWorkspacesRetrieve,
+ kClaudeTagSlackWorkspacesUpdate,
+ kComplianceSettingsRetrieve,
+ kComplianceSettingsUpdate,
+ kCostReportRetrieve,
+ kExternalKeysCreate,
+ kExternalKeysDelete,
+ kExternalKeysList,
+ kExternalKeysRetrieve,
+ kExternalKeysUpdate,
+ kExternalKeysValidate,
+ kInvitesCreate,
+ kInvitesDelete,
+ kInvitesList,
+ kInvitesRetrieve,
+ kMcpTunnelsArchive,
+ kMcpTunnelsCertificatesArchive,
+ kMcpTunnelsCertificatesCreate,
+ kMcpTunnelsCertificatesList,
+ kMcpTunnelsCertificatesRetrieve,
+ kMcpTunnelsList,
+ kMcpTunnelsRetrieve,
+ kMcpTunnelsRevealToken,
+ kMcpTunnelsRotateToken,
+ kOrganizationRetrieve,
+ kPluginMarketplacesList,
+ kPluginMarketplacesRetrieve,
+ kPluginMarketplacesUpdate,
+ kPluginMarketplacesValidateArchive,
+ kPluginMarketplacesValidateRepository,
+ kPluginsCreate,
+ kPluginsDelete,
+ kPluginsInstallationSettingsList,
+ kPluginsInstallationSettingsRemove,
+ kPluginsInstallationSettingsSet,
+ kPluginsList,
+ kPluginsRetrieve,
+ kPluginsSharesList,
+ kPluginsUpdate,
+ kPluginsVersionsCreate,
+ kPluginsVersionsDownload,
+ kPluginsVersionsList,
+ kPluginsVersionsRetrieve,
+ kRateLimitsList,
+ kRbacGroupsCreate,
+ kRbacGroupsDelete,
+ kRbacGroupsList,
+ kRbacGroupsMembersAdd,
+ kRbacGroupsMembersList,
+ kRbacGroupsMembersRemove,
+ kRbacGroupsRetrieve,
+ kRbacGroupsUpdate,
+ kRbacRolesList,
+ kRbacRolesPermissionsList,
+ kRbacRolesRetrieve,
+ kSpendLimitsDelete,
+ kSpendLimitsEffectiveList,
+ kSpendLimitsIncreaseRequestsApprove,
+ kSpendLimitsIncreaseRequestsDeny,
+ kSpendLimitsIncreaseRequestsList,
+ kSpendLimitsIncreaseRequestsRetrieve,
+ kSpendLimitsList,
+ kSpendLimitsRetrieve,
+ kSpendLimitsSet,
+ kTelemetryDestinationsCreate,
+ kTelemetryDestinationsDelete,
+ kTelemetryDestinationsList,
+ kTelemetryDestinationsRetrieve,
+ kTelemetryDestinationsTest,
+ kTelemetryDestinationsUpdate,
+ kTelemetryDestinationsWorkspacesAdd,
+ kTelemetryDestinationsWorkspacesList,
+ kTelemetryDestinationsWorkspacesRemove,
+ kUsageReportRetrieveClaudeCode,
+ kUsageReportRetrieveMessages,
+ kUsersList,
+ kUsersRemove,
+ kUsersRetrieve,
+ kUsersUpdate,
+ kWebhooksCreate,
+ kWebhooksDelete,
+ kWebhooksList,
+ kWebhooksRegenerateSigningSecret,
+ kWebhooksRetrieve,
+ kWebhooksUpdate,
+ kWorkspacesArchive,
+ kWorkspacesCreate,
+ kWorkspacesList,
+ kWorkspacesMembersAdd,
+ kWorkspacesMembersList,
+ kWorkspacesMembersRemove,
+ kWorkspacesMembersRetrieve,
+ kWorkspacesMembersUpdate,
+ kWorkspacesRateLimitsList,
+ kWorkspacesRateLimitsUpdate,
+ kWorkspacesRetrieve,
+ kWorkspacesUpdate,
+ kFederationIssuersArchive,
+ kFederationIssuersCreate,
+ kFederationIssuersList,
+ kFederationIssuersRetrieve,
+ kFederationIssuersUpdate,
+ kFederationRulesArchive,
+ kFederationRulesCreate,
+ kFederationRulesList,
+ kFederationRulesRetrieve,
+ kFederationRulesUpdate,
+ kFederationRulesWorkspacesAdd,
+ kFederationRulesWorkspacesList,
+ kFederationRulesWorkspacesRemove,
+ kServiceAccountsArchive,
+ kServiceAccountsCreate,
+ kServiceAccountsList,
+ kServiceAccountsRetrieve,
+ kServiceAccountsUpdate,
+ kServiceAccountsWorkspacesAdd,
+ kServiceAccountsWorkspacesList,
+ kServiceAccountsWorkspacesRemove,
+ kWorkspacesServiceAccountsAdd,
+ kWorkspacesServiceAccountsList,
+ kWorkspacesServiceAccountsRemove,
+ kWorkspacesServiceAccountsRetrieve,
+ kWorkspacesServiceAccountsUpdate,
+ kAgentsArchive,
+ kAgentsCreate,
+ kAgentsList,
+ kAgentsRetrieve,
+ kAgentsUpdate,
+ kAgentsVersionsList,
+ kDeploymentRunsList,
+ kDeploymentRunsRetrieve,
+ kDeploymentsArchive,
+ kDeploymentsCreate,
+ kDeploymentsList,
+ kDeploymentsPause,
+ kDeploymentsRetrieve,
+ kDeploymentsRun,
+ kDeploymentsUnpause,
+ kDeploymentsUpdate,
+ kDreamsArchive,
+ kDreamsCancel,
+ kDreamsCreate,
+ kDreamsList,
+ kDreamsRetrieve,
+ kEnvironmentsArchive,
+ kEnvironmentsCreate,
+ kEnvironmentsDelete,
+ kEnvironmentsList,
+ kEnvironmentsRetrieve,
+ kEnvironmentsUpdate,
+ kEnvironmentsWorkAck,
+ kEnvironmentsWorkHeartbeat,
+ kEnvironmentsWorkList,
+ kEnvironmentsWorkPoll,
+ kEnvironmentsWorkRetrieve,
+ kEnvironmentsWorkStats,
+ kEnvironmentsWorkStop,
+ kEnvironmentsWorkUpdate,
+ kMemoryStoresArchive,
+ kMemoryStoresCreate,
+ kMemoryStoresDelete,
+ kMemoryStoresList,
+ kMemoryStoresMemoriesCreate,
+ kMemoryStoresMemoriesDelete,
+ kMemoryStoresMemoriesList,
+ kMemoryStoresMemoriesRetrieve,
+ kMemoryStoresMemoriesUpdate,
+ kMemoryStoresMemoryVersionsList,
+ kMemoryStoresMemoryVersionsRedact,
+ kMemoryStoresMemoryVersionsRetrieve,
+ kMemoryStoresRetrieve,
+ kMemoryStoresUpdate,
+ kSessionsArchive,
+ kSessionsCreate,
+ kSessionsDelete,
+ kSessionsEventsList,
+ kSessionsEventsSend,
+ kSessionsEventsStream,
+ kSessionsList,
+ kSessionsResourcesAdd,
+ kSessionsResourcesDelete,
+ kSessionsResourcesList,
+ kSessionsResourcesRetrieve,
+ kSessionsResourcesUpdate,
+ kSessionsRetrieve,
+ kSessionsThreadsArchive,
+ kSessionsThreadsEventsList,
+ kSessionsThreadsEventsStream,
+ kSessionsThreadsList,
+ kSessionsThreadsRetrieve,
+ kSessionsUpdate,
+ kTunnelsArchive,
+ kTunnelsCertificatesArchive,
+ kTunnelsCertificatesCreate,
+ kTunnelsCertificatesList,
+ kTunnelsCertificatesRetrieve,
+ kTunnelsCreate,
+ kTunnelsList,
+ kTunnelsRetrieve,
+ kTunnelsRevealToken,
+ kTunnelsRotateToken,
+ kUserProfilesActionUrlsCreate,
+ kUserProfilesActionUrlsCreateBeta,
+ kUserProfilesCreate,
+ kUserProfilesCreateBeta,
+ kUserProfilesCreateEnrollmentUrl,
+ kUserProfilesDelete,
+ kUserProfilesDeleteBeta,
+ kUserProfilesList,
+ kUserProfilesListBeta,
+ kUserProfilesRetrieve,
+ kUserProfilesRetrieveBeta,
+ kUserProfilesUpdate,
+ kUserProfilesUpdateBeta,
+ kVaultsArchive,
+ kVaultsCreate,
+ kVaultsCredentialsArchive,
+ kVaultsCredentialsCreate,
+ kVaultsCredentialsDelete,
+ kVaultsCredentialsList,
+ kVaultsCredentialsMcpOauthValidate,
+ kVaultsCredentialsRetrieve,
+ kVaultsCredentialsUpdate,
+ kVaultsDelete,
+ kVaultsList,
+ kVaultsRetrieve,
+ kVaultsUpdate,
+};
+
+// Which credential a call needs.
+enum class Auth {
+ kAdmin, // Admin API key (sk-ant-admin..., x-api-key) or an org:admin OAuth token
+ kOAuth, // only an org:admin OAuth bearer token (service accounts, federation)
+ kPlatform, // standard workspace API key (managed agents surface)
+};
+
+enum class Kind { kRead, kWrite, kDestructive };
+enum class Page { kNone, kIds, kCursor, kReport, kBidirectional };
+enum class Wire { kJson, kSse, kMultipart, kRaw };
+
+struct CallSpec {
+ Call call;
+ const char* name; // SDK-style operation id, e.g. organization.invites.create
+ const char* http; // GET POST PATCH DELETE
+ const char* path; // /v1/organizations/invites/{invite_id}
+ const char* docs; // reference page slug, guide:, or "" (SDK only)
+ const char* request; // SDK request schema (TypedDict) or ""
+ const char* response; // SDK response type
+ const char* body; // comma list: JSON body fields (multipart: part names)
+ const char* required; // comma list: required body fields and query parameters
+ const char* query; // comma list: query parameters; `name[]` is sent repeated
+ const char* headers; // comma list: arg=Header-Name request header parameters
+ const char* beta; // anthropic-beta value the call needs, or ""
+ Auth auth;
+ Kind kind;
+ Page page;
+ Wire wire;
+ bool workspace; // accepts the anthropic-workspace-id header
+ bool docs_only; // not in any SDK: reference page is the only source
+};
+
+const CallSpec& spec_of(Call call);
+clients::Method method_of(Call call);
+std::size_t call_count();
+const CallSpec& spec_at(std::size_t index);
+
+} // namespace molo::anthropic::admin
diff --git a/src/anthropic/admin/caps.h b/src/anthropic/admin/caps.h
new file mode 100644
index 0000000..fee7ed8
--- /dev/null
+++ b/src/anthropic/admin/caps.h
@@ -0,0 +1,36 @@
+#pragma once
+
+// Static ceilings for the Anthropic admin and agent-platform package. Never
+// autotuned: a constant you can read beats magic you cannot debug.
+
+#include
+
+namespace molo::anthropic::admin {
+
+struct Caps {
+ // Page walks: pages fetched and items collected by one list_all call.
+ static constexpr std::size_t kMaxPages = 20;
+ static constexpr std::size_t kMaxPagesHard = 100;
+ static constexpr std::size_t kMaxItems = 5000;
+ // Ids put into a URL path (see llm::Service::valid_id).
+ static constexpr std::size_t kMaxIdBytes = 256;
+ // JSON request body.
+ static constexpr std::size_t kMaxBodyBytes = 1u * 1024u * 1024u;
+ // Query string: values per parameter, bytes per value, bytes in total.
+ static constexpr std::size_t kMaxQueryValues = 100;
+ static constexpr std::size_t kMaxQueryValueBytes = 512;
+ static constexpr std::size_t kMaxQueryBytes = 8u * 1024u;
+ // Multipart uploads (plugin files, marketplace archive: the API caps the
+ // archive at 32 MiB).
+ static constexpr std::size_t kMaxFormBytes = 32u * 1024u * 1024u;
+ static constexpr std::size_t kMaxFormParts = 512;
+ // Server-sent event streams: events handed to the sink.
+ static constexpr std::size_t kMaxStreamEvents = 1000;
+ // Largest page size this package ever sends.
+ static constexpr long kMaxLimit = 1000;
+ // Webhook signature timestamp tolerance, seconds (Standard Webhooks: 5 min).
+ static constexpr long kWebhookToleranceSeconds = 300;
+ static constexpr std::size_t kMaxWebhookPayloadBytes = 1u * 1024u * 1024u;
+};
+
+} // namespace molo::anthropic::admin
diff --git a/src/anthropic/admin/credentials.cpp b/src/anthropic/admin/credentials.cpp
new file mode 100644
index 0000000..b67447b
--- /dev/null
+++ b/src/anthropic/admin/credentials.cpp
@@ -0,0 +1,71 @@
+#include "anthropic/admin/credentials.h"
+
+namespace molo::anthropic::admin {
+
+namespace {
+bool starts_with(const std::string& s, const char* prefix) {
+ return s.rfind(prefix, 0) == 0;
+}
+bool clean(const std::string& s) {
+ for (unsigned char c : s)
+ if (c <= 0x20 || c >= 0x7f) return false;
+ return true;
+}
+} // namespace
+
+const char* KeyRules::env_of(Lane lane) {
+ switch (lane) {
+ case Lane::kAdminKey: return "ANTHROPIC_ADMIN_KEY";
+ case Lane::kOAuth: return "ANTHROPIC_AUTH_TOKEN";
+ case Lane::kPlatform: return "ANTHROPIC_API_KEY";
+ }
+ return "";
+}
+
+const char* KeyRules::name_of(Lane lane) {
+ switch (lane) {
+ case Lane::kAdminKey: return "admin_key";
+ case Lane::kOAuth: return "oauth_token";
+ case Lane::kPlatform: return "api_key";
+ }
+ return "";
+}
+
+bool KeyRules::is_admin_key(const std::string& value) { return starts_with(value, kAdminPrefix); }
+
+LaneState KeyRules::check(Lane lane, const std::string& value, std::string& reason) {
+ reason.clear();
+ if (value.empty()) return LaneState::kMissing;
+ if (!clean(value)) {
+ reason = std::string(env_of(lane)) + " has whitespace or control characters";
+ return LaneState::kRejected;
+ }
+ switch (lane) {
+ case Lane::kAdminKey:
+ if (!is_admin_key(value)) {
+ reason = std::string(env_of(lane)) + " must be an Admin API key (sk-ant-admin...); a standard API key is not accepted";
+ return LaneState::kRejected;
+ }
+ break;
+ case Lane::kOAuth:
+ if (is_admin_key(value) || starts_with(value, kApiPrefix)) {
+ reason = std::string(env_of(lane)) + " must be an org:admin OAuth token, not an API key";
+ return LaneState::kRejected;
+ }
+ break;
+ case Lane::kPlatform:
+ if (is_admin_key(value)) {
+ reason = std::string(env_of(lane)) + " is an Admin API key; managed agents take a standard workspace key";
+ return LaneState::kRejected;
+ }
+ break;
+ }
+ return LaneState::kReady;
+}
+
+std::string KeyRules::redacted(const std::string& value) {
+ if (value.size() <= 12) return std::string(value.size(), '*');
+ return value.substr(0, 12) + "...";
+}
+
+} // namespace molo::anthropic::admin
diff --git a/src/anthropic/admin/credentials.h b/src/anthropic/admin/credentials.h
new file mode 100644
index 0000000..4f6824b
--- /dev/null
+++ b/src/anthropic/admin/credentials.h
@@ -0,0 +1,47 @@
+#pragma once
+
+// Credential rules. The package talks with three credentials, each kept in
+// its own lane and never mixed up:
+//
+// kAdminKey ANTHROPIC_ADMIN_KEY sk-ant-admin..., header x-api-key
+// kOAuth ANTHROPIC_AUTH_TOKEN org:admin OAuth token, Authorization: Bearer
+// kPlatform ANTHROPIC_API_KEY standard workspace key (managed agents)
+//
+// A lane refuses a credential of the wrong kind before any request leaves
+// the process: the standard key is never accepted as an admin key, and an
+// admin key never goes to the platform lane.
+
+#include
+
+namespace molo::anthropic::admin {
+
+enum class Lane { kAdminKey, kOAuth, kPlatform };
+
+enum class LaneState {
+ kMissing, // nothing configured
+ kReady, // configured and plausible for this lane
+ kRejected, // configured but of the wrong kind; calls fail locally
+};
+
+struct LaneInfo {
+ Lane lane;
+ const char* env; // environment variable that feeds the lane
+ LaneState state;
+ std::string reason; // why a credential was rejected, else ""
+};
+
+class KeyRules {
+ public:
+ static constexpr const char* kAdminPrefix = "sk-ant-admin";
+ static constexpr const char* kApiPrefix = "sk-ant-api";
+
+ static const char* env_of(Lane lane);
+ static const char* name_of(Lane lane);
+ // Classifies `value` for `lane`; fills `reason` on rejection.
+ static LaneState check(Lane lane, const std::string& value, std::string& reason);
+ static bool is_admin_key(const std::string& value);
+ // First 12 characters then "...": safe to show, never the whole key.
+ static std::string redacted(const std::string& value);
+};
+
+} // namespace molo::anthropic::admin
diff --git a/src/anthropic/admin/gateway.cpp b/src/anthropic/admin/gateway.cpp
new file mode 100644
index 0000000..60b76a7
--- /dev/null
+++ b/src/anthropic/admin/gateway.cpp
@@ -0,0 +1,162 @@
+#include "anthropic/admin/gateway.h"
+
+#include
+
+#include "anthropic/admin/caps.h"
+#include "clients/transports/http_transport.h"
+#include "llm/config.h"
+#include "llm/error.h"
+
+namespace molo::anthropic::admin {
+
+namespace {
+
+constexpr const char* kVendor = "anthropic";
+
+std::size_t index_of(Lane lane) { return static_cast(lane); }
+
+Lane lane_of(Auth auth) {
+ switch (auth) {
+ case Auth::kAdmin: return Lane::kAdminKey;
+ case Auth::kOAuth: return Lane::kOAuth;
+ case Auth::kPlatform: return Lane::kPlatform;
+ }
+ return Lane::kAdminKey;
+}
+
+std::mutex& stream_mutex() {
+ static std::mutex m;
+ return m;
+}
+
+} // namespace
+
+Gateway::Gateway(TransportFactory factory, Keys keys, std::string base_url)
+ : base_url_(std::move(base_url)), factory_(std::move(factory)) {
+ const std::string values[3] = {keys.admin_key, keys.oauth_token, keys.api_key};
+ const Lane order[3] = {Lane::kAdminKey, Lane::kOAuth, Lane::kPlatform};
+ for (int i = 0; i < 3; ++i) {
+ Slot& s = slots_[index_of(order[i])];
+ s.info.lane = order[i];
+ s.info.env = KeyRules::env_of(order[i]);
+ s.info.state = KeyRules::check(order[i], values[i], s.info.reason);
+ s.key = s.info.state == LaneState::kReady ? values[i] : std::string();
+ s.config.vendor = kVendor;
+ s.config.base_url = base_url_;
+ s.config.key_env = s.info.env;
+ s.config.auth = order[i] == Lane::kOAuth ? llm::AuthStyle::kBearer : llm::AuthStyle::kHeader;
+ s.config.auth_header = "x-api-key";
+ s.config.default_headers["anthropic-version"] = kApiVersion;
+ s.client = std::make_shared(factory_(), s.config, s.key);
+ }
+}
+
+std::shared_ptr Gateway::from_env() {
+ Keys keys;
+ keys.admin_key = llm::Config::get(KeyRules::env_of(Lane::kAdminKey));
+ keys.oauth_token = llm::Config::get(KeyRules::env_of(Lane::kOAuth));
+ keys.api_key = llm::Config::get(KeyRules::env_of(Lane::kPlatform));
+ return std::make_shared(
+ [] { return std::unique_ptr(new clients::transports::HttpTransport()); },
+ std::move(keys));
+}
+
+const Gateway::Slot& Gateway::slot(Lane lane) const { return slots_[index_of(lane)]; }
+
+LaneInfo Gateway::describe(Lane lane) const { return slot(lane).info; }
+
+std::vector Gateway::lanes() const {
+ return {slot(Lane::kAdminKey).info, slot(Lane::kOAuth).info, slot(Lane::kPlatform).info};
+}
+
+std::shared_ptr Gateway::primary_client(Auth auth) const {
+ return slot(lane_of(auth)).client;
+}
+
+Lane Gateway::lane_for(Auth auth) const {
+ auto refuse = [&](const LaneInfo& info) -> void {
+ if (info.state == LaneState::kRejected)
+ throw llm::ApiError(kVendor, 401, "credential_rejected", info.reason);
+ };
+ switch (auth) {
+ case Auth::kAdmin: {
+ const LaneInfo& key = slot(Lane::kAdminKey).info;
+ const LaneInfo& tok = slot(Lane::kOAuth).info;
+ if (key.state == LaneState::kReady) return Lane::kAdminKey;
+ if (tok.state == LaneState::kReady) return Lane::kOAuth;
+ refuse(key);
+ refuse(tok);
+ throw llm::NotConfiguredError(kVendor, KeyRules::env_of(Lane::kAdminKey));
+ }
+ case Auth::kOAuth: {
+ const LaneInfo& tok = slot(Lane::kOAuth).info;
+ if (tok.state == LaneState::kReady) return Lane::kOAuth;
+ refuse(tok);
+ if (slot(Lane::kAdminKey).info.state == LaneState::kReady)
+ throw llm::ApiError(kVendor, 403, "credential_rejected",
+ "this call accepts only an org:admin OAuth token (set ANTHROPIC_AUTH_TOKEN); an Admin API key is not accepted");
+ throw llm::NotConfiguredError(kVendor, KeyRules::env_of(Lane::kOAuth));
+ }
+ case Auth::kPlatform: {
+ const LaneInfo& k = slot(Lane::kPlatform).info;
+ if (k.state == LaneState::kReady) return Lane::kPlatform;
+ refuse(k);
+ throw llm::NotConfiguredError(kVendor, KeyRules::env_of(Lane::kPlatform));
+ }
+ }
+ throw llm::ApiError(kVendor, 500, "internal", "unknown credential class");
+}
+
+std::shared_ptr Gateway::client_for(Auth auth) const {
+ return slot(lane_for(auth)).client;
+}
+
+bool Gateway::ready(Auth auth) const {
+ try {
+ lane_for(auth);
+ return true;
+ } catch (const llm::ApiError&) {
+ return false;
+ }
+}
+
+void Gateway::set_workspace_id(std::string id) {
+ if (!id.empty() && !llm::Service::valid_id(id))
+ throw llm::ApiError::invalid(kVendor, "bad workspace id");
+ workspace_id_ = std::move(id);
+}
+
+void Gateway::stream_get(Auth auth, const std::string& target,
+ const std::map& headers,
+ const llm::SseDecoder::Sink& sink, std::size_t max_events) const {
+ const Slot& s = slot(lane_for(auth));
+ if (target.empty() || target.front() != '/' || target.find("..") != std::string::npos)
+ throw llm::ApiError::invalid(kVendor, "bad request path");
+ if (max_events == 0 || max_events > Caps::kMaxStreamEvents)
+ throw llm::ApiError::invalid(kVendor, "max_events must be 1.." + std::to_string(Caps::kMaxStreamEvents));
+ std::lock_guard lock(stream_mutex());
+ if (!stream_client_) stream_client_ = std::make_unique(factory_());
+ std::size_t seen = 0;
+ llm::SseDecoder decoder(kVendor, [&](const llm::SseEvent& ev) {
+ ++seen;
+ bool keep = sink(ev);
+ return keep && seen < max_events;
+ });
+ try {
+ clients::ClientRequest req(clients::Method::kGet, clients::Url::parse(base_url_ + target));
+ if (s.config.auth == llm::AuthStyle::kBearer) req.bearer(s.key);
+ else req.header(s.config.auth_header, s.key);
+ for (const auto& [k, v] : s.config.default_headers) req.header(k, v);
+ for (const auto& [k, v] : headers) req.header(k, v);
+ req.header("Accept", "text/event-stream");
+ stream_client_->send_stream_blocking(std::move(req),
+ [&](const std::string& chunk) { return decoder.feed(chunk); });
+ decoder.finish();
+ } catch (const llm::ApiError&) {
+ throw;
+ } catch (const std::exception& e) {
+ throw llm::ApiError(kVendor, 502, "UNAVAILABLE", e.what());
+ }
+}
+
+} // namespace molo::anthropic::admin
diff --git a/src/anthropic/admin/gateway.h b/src/anthropic/admin/gateway.h
new file mode 100644
index 0000000..fb452f2
--- /dev/null
+++ b/src/anthropic/admin/gateway.h
@@ -0,0 +1,84 @@
+#pragma once
+
+// Gateway: the three credential lanes behind one object. Owns one
+// llm::ApiClient per lane (x-api-key for the admin key and the standard key,
+// Authorization: Bearer for the OAuth token, anthropic-version on all) and
+// picks the lane a call needs from the call table. A lane holding a
+// credential of the wrong kind refuses locally; the request never leaves.
+
+#include
+#include