Merge anthropic core package
This commit is contained in:
@@ -1,13 +1,512 @@
|
||||
#include "../AiDemos.hpp"
|
||||
|
||||
#include "../../fw/Router.hpp"
|
||||
#include "../../fw/Templates.hpp"
|
||||
#include "anthropic/core/anthropic.h"
|
||||
#include "anthropic/core/caps.h"
|
||||
|
||||
namespace molo::example::app {
|
||||
|
||||
// Anthropic Claude: messages, streaming, tools, batches, tokens, models, files, skills. Stub: the module agent fills this in.
|
||||
// Anthropic Claude (api.anthropic.com) over src/anthropic/core. GET routes need
|
||||
// no credential. Routes that call the vendor are POST: 422 on bad input first,
|
||||
// then 503 anthropic_not_configured without ANTHROPIC_API_KEY. Anything that
|
||||
// costs money (messages, stream, batch create) or deletes is a dry run unless
|
||||
// the body has "confirm":true. /ai/anthropic/build only builds and validates
|
||||
// the request offline.
|
||||
|
||||
namespace {
|
||||
|
||||
namespace core = anthropic::core;
|
||||
using Json = clients::body::Json;
|
||||
|
||||
constexpr std::size_t kMaxBody = 512 * 1024;
|
||||
constexpr std::size_t kMaxStreamEventsShown = 200;
|
||||
|
||||
const char kPage[] = R"ANTHROPIC({% extends "base.html" %}
|
||||
{% block content %}
|
||||
<h1>Anthropic Claude</h1>
|
||||
<p class="hint">Messages, streaming, tools, batches, token counting, models, files,
|
||||
skills. Calls that cost money or delete are dry runs until the body says
|
||||
<code>"confirm":true</code>.</p>
|
||||
<p id="an-config" class="hint">Checking credentials...</p>
|
||||
<section class="an">
|
||||
<label>Route
|
||||
<select id="an-route">
|
||||
<option value="build">Build request (offline check)</option>
|
||||
<option value="count">Count tokens</option>
|
||||
<option value="messages">Messages (paid)</option>
|
||||
<option value="stream">Stream (paid)</option>
|
||||
<option value="models">Models</option>
|
||||
<option value="batches">Batches</option>
|
||||
<option value="files">Files</option>
|
||||
<option value="skills">Skills</option>
|
||||
<option value="profiles">User profiles</option>
|
||||
</select></label>
|
||||
<label>Body (JSON object) <textarea id="an-body" rows="10"></textarea></label>
|
||||
<div class="an-actions">
|
||||
<button id="an-send" type="button" class="primary">Send</button>
|
||||
<button id="an-reset" type="button">Example body</button>
|
||||
</div>
|
||||
<p id="an-error" class="error" role="alert"></p>
|
||||
<pre id="an-out" class="an-out"></pre>
|
||||
</section>
|
||||
<style>
|
||||
.an label{display:block;margin:.5rem 0}
|
||||
.an select,.an textarea{width:100%;box-sizing:border-box}
|
||||
.an-actions{display:flex;flex-wrap:wrap;gap:.5rem;margin:.5rem 0}
|
||||
.an-out{overflow:auto;max-height:24rem;white-space:pre-wrap;word-break:break-word}
|
||||
</style>
|
||||
<script src="/embedded/ai_anthropic_core.js"></script>
|
||||
{% endblock %}
|
||||
)ANTHROPIC";
|
||||
|
||||
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); }
|
||||
|
||||
template <typename F>
|
||||
auto guarded(F&& f) -> decltype(f()) {
|
||||
try {
|
||||
return f();
|
||||
} catch (const core::AnthropicError& e) {
|
||||
if (e.kind() == core::ErrorKind::kNotConfigured)
|
||||
throw fw::HttpError(503, "anthropic_not_configured", e.message());
|
||||
if (e.kind() == core::ErrorKind::kInvalidArgument) throw fw::HttpError(422, "validation_error", e.message());
|
||||
throw fw::HttpError(502, "anthropic_error", e.type() + ": " + e.message());
|
||||
} catch (const llm::ApiError& e) {
|
||||
if (e.type() == "NOT_CONFIGURED") throw fw::HttpError(503, "anthropic_not_configured", e.message());
|
||||
if (e.type() == "INVALID_ARGUMENT") throw fw::HttpError(422, "validation_error", e.message());
|
||||
throw fw::HttpError(502, "anthropic_error", e.type() + ": " + e.message());
|
||||
}
|
||||
}
|
||||
|
||||
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, bool required = false) {
|
||||
const Json* v = body.find(key);
|
||||
if (!v || v->is_null()) {
|
||||
if (required) bad(std::string(key) + " is required");
|
||||
return "";
|
||||
}
|
||||
if (!v->is_string()) bad(std::string(key) + " must be a string");
|
||||
return v->as_string();
|
||||
}
|
||||
|
||||
int number(const Json& body, const char* key, int fallback = 0) {
|
||||
const Json* v = body.find(key);
|
||||
if (!v || v->is_null()) return fallback;
|
||||
if (!v->is_number()) bad(std::string(key) + " must be a number");
|
||||
return static_cast<int>(v->as_int());
|
||||
}
|
||||
|
||||
bool confirmed(const Json& body) {
|
||||
const Json* c = body.find("confirm");
|
||||
if (c && !c->is_bool()) bad("confirm must be true or false");
|
||||
return c && c->as_bool();
|
||||
}
|
||||
|
||||
Json dry_run(const std::string& what, const Json& detail) {
|
||||
Json o = Json::object();
|
||||
o.set("dry_run", Json(true));
|
||||
o.set("would", Json(what));
|
||||
o.set("request", detail);
|
||||
o.set("hint", Json("send confirm:true to run it"));
|
||||
return o;
|
||||
}
|
||||
|
||||
// Maps the demo's JSON body onto a typed request; every rule is the module's.
|
||||
core::MessageRequest request_from(const Json& body) {
|
||||
core::MessageRequest r;
|
||||
r.model = text(body, "model", true);
|
||||
r.set_max_tokens(number(body, "max_tokens", 256));
|
||||
r.system_text = text(body, "system");
|
||||
const Json* ms = body.find("messages");
|
||||
if (ms && ms->is_array()) {
|
||||
for (const Json& m : ms->as_array()) {
|
||||
std::string role = text(m, "role", true);
|
||||
const Json* c = m.find("content");
|
||||
if (!c) bad("every message needs content");
|
||||
core::MessageParam p;
|
||||
if (role == "user") p.role = core::MessageParam::Role::kUser;
|
||||
else if (role == "assistant") p.role = core::MessageParam::Role::kAssistant;
|
||||
else if (role == "system") p.role = core::MessageParam::Role::kSystem;
|
||||
else bad("role must be user, assistant or system");
|
||||
if (c->is_string()) {
|
||||
p.text = c->as_string();
|
||||
} else if (c->is_array()) {
|
||||
for (const Json& b : c->as_array()) p.blocks.push_back(core::ContentBlock::from_json(b));
|
||||
} else {
|
||||
bad("content must be a string or an array of blocks");
|
||||
}
|
||||
r.add(std::move(p));
|
||||
}
|
||||
} else if (!text(body, "prompt").empty()) {
|
||||
r.add(core::MessageParam::user(text(body, "prompt")));
|
||||
} else {
|
||||
bad("messages (array) or prompt (string) is required");
|
||||
}
|
||||
if (const Json* ts = body.find("tools")) {
|
||||
if (!ts->is_array()) bad("tools must be an array");
|
||||
for (const Json& t : ts->as_array()) r.add_tool(core::Tool::from_json(t));
|
||||
}
|
||||
std::string tc = text(body, "tool_choice");
|
||||
if (tc == "auto") r.tool_choice = core::ToolChoice::auto_();
|
||||
else if (tc == "any") r.tool_choice = core::ToolChoice::any();
|
||||
else if (tc == "none") r.tool_choice = core::ToolChoice::none();
|
||||
else if (!tc.empty()) r.tool_choice = core::ToolChoice::tool(tc);
|
||||
if (const Json* th = body.find("thinking"); th && th->is_object()) {
|
||||
std::string t = text(*th, "type", true);
|
||||
if (t == "enabled") r.thinking = core::ThinkingConfig::enabled(number(*th, "budget_tokens"));
|
||||
else if (t == "adaptive") r.thinking = core::ThinkingConfig::adaptive();
|
||||
else if (t == "disabled") r.thinking = core::ThinkingConfig::disabled();
|
||||
else if (t == "between_tools") r.thinking = core::ThinkingConfig::between_tools();
|
||||
else bad("thinking.type is not valid");
|
||||
}
|
||||
r.output.effort = text(body, "effort");
|
||||
r.speed = text(body, "speed");
|
||||
r.user_profile_id = text(body, "user_profile_id");
|
||||
if (const Json* ss = body.find("stop_sequences"); ss && ss->is_array())
|
||||
for (const Json& s : ss->as_array()) {
|
||||
if (!s.is_string()) bad("stop_sequences must be strings");
|
||||
r.stop_sequences.push_back(s.as_string());
|
||||
}
|
||||
if (const Json* b = body.find("betas")) {
|
||||
if (!b->is_array()) bad("betas must be an array of strings");
|
||||
for (const Json& n : b->as_array()) {
|
||||
if (!n.is_string()) bad("betas must be an array of strings");
|
||||
r.betas.add_name(n.as_string());
|
||||
}
|
||||
}
|
||||
if (const Json* t = body.find("temperature")) r.temperature = t->is_number() ? t->as_number() : (bad("temperature must be a number"), 0.0);
|
||||
return r;
|
||||
}
|
||||
|
||||
core::ApiVersion version_from(const Json& body) {
|
||||
std::string v = text(body, "version");
|
||||
return v.empty() ? core::kDefaultVersion : core::parse_version(v);
|
||||
}
|
||||
|
||||
Json built(const core::MessageRequest& r, core::ApiVersion v, bool stream) {
|
||||
r.validate(v);
|
||||
Json o = Json::object();
|
||||
o.set("anthropic_version", Json(core::version_name(v)));
|
||||
o.set("anthropic_beta", Json(r.effective_betas().header_value()));
|
||||
o.set("body", r.to_json(stream, v));
|
||||
return o;
|
||||
}
|
||||
|
||||
std::vector<std::string> id_list(const Json& body, const char* key) {
|
||||
std::vector<std::string> out;
|
||||
if (const Json* a = body.find(key)) {
|
||||
if (!a->is_array()) bad(std::string(key) + " must be an array of strings");
|
||||
for (const Json& s : a->as_array()) {
|
||||
if (!s.is_string()) bad(std::string(key) + " must be an array of strings");
|
||||
out.push_back(s.as_string());
|
||||
}
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
Json page_json(const core::Page& p) {
|
||||
Json o = Json::object();
|
||||
o.set("data", Json(p.data));
|
||||
o.set("has_more", Json(p.has_more));
|
||||
o.set("truncated", Json(p.truncated));
|
||||
if (!p.next_page.empty()) o.set("next_page", Json(p.next_page));
|
||||
if (!p.last_id.empty()) o.set("last_id", Json(p.last_id));
|
||||
return o;
|
||||
}
|
||||
|
||||
void need_id(const std::string& id) {
|
||||
if (!llm::Service::valid_id(id)) bad("id must be one segment of A-Z a-z 0-9 . _ : -");
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
void register_ai_anthropic_demo(fw::Router& router, Services& services) {
|
||||
(void)router;
|
||||
(void)services;
|
||||
auto api = std::make_shared<core::Anthropic>(core::Anthropic::from_env());
|
||||
fw::Environment* env = services.templates.get();
|
||||
services.templates->add_template("ai_anthropic.html", kPage);
|
||||
services.add_feature("ai-anthropic", "/ai/anthropic");
|
||||
|
||||
router.get("/ai/anthropic", "ai-anthropic-page", [env](fw::Request req) {
|
||||
(void)req;
|
||||
fw::TemplateCtx ctx;
|
||||
ctx["title"] = std::string("Anthropic Claude");
|
||||
return fw::Response(200, env->render("ai_anthropic.html", ctx), "text/html; charset=utf-8");
|
||||
});
|
||||
|
||||
router.get("/ai/anthropic/status", "ai-anthropic-status", [api](fw::Request req) {
|
||||
(void)req;
|
||||
Json o = Json::object();
|
||||
o.set("configured", Json(api->configured()));
|
||||
o.set("key_env", Json(api->session().options().key_env));
|
||||
o.set("base_url", Json(api->session().options().base_url));
|
||||
o.set("default_version", Json(core::version_name(core::kDefaultVersion)));
|
||||
o.set("calls", Json(static_cast<int>(core::call_count())));
|
||||
o.set("betas", Json(static_cast<int>(core::beta_count())));
|
||||
o.set("tool_types", Json(static_cast<int>(core::tool_schema_count())));
|
||||
o.set("block_types", Json(static_cast<int>(core::block_schema_count())));
|
||||
o.set("max_stream_events", Json(static_cast<int>(kMaxStreamEventsShown)));
|
||||
return json_out(o);
|
||||
});
|
||||
|
||||
router.get("/ai/anthropic/calls", "ai-anthropic-calls", [](fw::Request req) {
|
||||
(void)req;
|
||||
Json arr = Json::array();
|
||||
for (std::size_t i = 0; i < core::call_count(); ++i) {
|
||||
const core::CallSpec& s = core::spec_at(i);
|
||||
Json row = Json::object();
|
||||
row.set("key", Json(s.key));
|
||||
row.set("http", Json(s.http_method));
|
||||
row.set("path", Json(s.path));
|
||||
row.set("body_fields", Json(s.body_fields));
|
||||
row.set("query_params", Json(s.query_params));
|
||||
arr.push(row);
|
||||
}
|
||||
Json o = Json::object();
|
||||
o.set("calls", arr);
|
||||
return json_out(o);
|
||||
});
|
||||
|
||||
router.get("/ai/anthropic/betas", "ai-anthropic-betas", [](fw::Request req) {
|
||||
(void)req;
|
||||
Json arr = Json::array();
|
||||
for (std::size_t i = 0; i < core::beta_count(); ++i) {
|
||||
const core::BetaInfo& b = core::beta_at(i);
|
||||
Json row = Json::object();
|
||||
row.set("name", Json(b.wire));
|
||||
row.set("status", Json(b.status == core::BetaStatus::kCurrent ? "current"
|
||||
: b.status == core::BetaStatus::kLegacy ? "legacy"
|
||||
: b.status == core::BetaStatus::kOtherPackage ? "admin_package"
|
||||
: "unknown"));
|
||||
row.set("meaning", Json(b.meaning));
|
||||
arr.push(row);
|
||||
}
|
||||
Json o = Json::object();
|
||||
o.set("betas", arr);
|
||||
return json_out(o);
|
||||
});
|
||||
|
||||
router.get("/ai/anthropic/tools", "ai-anthropic-tools", [](fw::Request req) {
|
||||
(void)req;
|
||||
Json arr = Json::array();
|
||||
for (std::size_t i = 0; i < core::tool_schema_count(); ++i) {
|
||||
const core::ToolSchema& t = core::tool_schema_at(i);
|
||||
Json row = Json::object();
|
||||
row.set("type", Json(t.type));
|
||||
row.set("name", Json(t.name));
|
||||
row.set("beta", Json(t.beta));
|
||||
row.set("ga", Json(t.ga));
|
||||
arr.push(row);
|
||||
}
|
||||
Json o = Json::object();
|
||||
o.set("tools", arr);
|
||||
return json_out(o);
|
||||
});
|
||||
|
||||
// Offline: builds and validates, never calls the vendor.
|
||||
router.post("/ai/anthropic/build", "ai-anthropic-build", [](fw::Request req) {
|
||||
Json body = parse_body(req);
|
||||
return guarded([&] { return json_out(built(request_from(body), version_from(body), false)); });
|
||||
});
|
||||
|
||||
router.post("/ai/anthropic/count", "ai-anthropic-count", [api](fw::Request req) {
|
||||
Json body = parse_body(req);
|
||||
return guarded([&] {
|
||||
core::MessageRequest r = request_from(body);
|
||||
r.validate(version_from(body));
|
||||
core::TokenCount t = api->messages->count_tokens(r);
|
||||
return json_out(t.raw);
|
||||
});
|
||||
});
|
||||
|
||||
router.post("/ai/anthropic/messages", "ai-anthropic-messages", [api](fw::Request req) {
|
||||
Json body = parse_body(req);
|
||||
return guarded([&] {
|
||||
core::MessageRequest r = request_from(body);
|
||||
Json plan = built(r, version_from(body), false);
|
||||
if (!confirmed(body)) return json_out(dry_run("create a message", plan));
|
||||
core::MessageResult res = api->messages->create(r);
|
||||
Json o = Json::object();
|
||||
o.set("message", res.message.raw);
|
||||
o.set("text", Json(res.message.text()));
|
||||
o.set("betas_sent", Json(res.betas.header_value()));
|
||||
o.set("request_id", Json(res.limits.request_id));
|
||||
return json_out(o);
|
||||
});
|
||||
});
|
||||
|
||||
router.post("/ai/anthropic/stream", "ai-anthropic-stream", [api](fw::Request req) {
|
||||
Json body = parse_body(req);
|
||||
return guarded([&] {
|
||||
core::MessageRequest r = request_from(body);
|
||||
Json plan = built(r, version_from(body), true);
|
||||
if (!confirmed(body)) return json_out(dry_run("stream a message", plan));
|
||||
Json events = Json::array();
|
||||
core::StreamResult res = api->messages->stream(r, [&](const core::StreamEvent& e) {
|
||||
events.push(e.data);
|
||||
return events.as_array().size() < kMaxStreamEventsShown;
|
||||
});
|
||||
Json o = Json::object();
|
||||
o.set("events", events);
|
||||
o.set("complete", Json(res.complete));
|
||||
o.set("message", res.message.raw);
|
||||
return json_out(o);
|
||||
});
|
||||
});
|
||||
|
||||
router.post("/ai/anthropic/models", "ai-anthropic-models", [api](fw::Request req) {
|
||||
Json body = parse_body(req);
|
||||
std::string id = text(body, "id");
|
||||
if (!id.empty()) need_id(id);
|
||||
int limit = number(body, "limit", 0);
|
||||
return guarded([&] {
|
||||
if (!id.empty()) return json_out(api->models->retrieve(id).raw);
|
||||
return json_out(page_json(api->models->list(limit, "", "", id_list(body, "lifecycle"))));
|
||||
});
|
||||
});
|
||||
|
||||
router.post("/ai/anthropic/batches", "ai-anthropic-batches", [api](fw::Request req) {
|
||||
Json body = parse_body(req);
|
||||
std::string action = text(body, "action", true);
|
||||
std::string id = text(body, "id");
|
||||
if (action != "create" && action != "get" && action != "list" && action != "cancel" && action != "delete" &&
|
||||
action != "results")
|
||||
bad("action must be create, get, list, cancel, delete or results");
|
||||
if (action != "create" && action != "list") {
|
||||
if (id.empty()) bad("id is required");
|
||||
need_id(id);
|
||||
}
|
||||
return guarded([&] {
|
||||
if (action == "list") return json_out(page_json(api->batches->list(number(body, "limit", 0))));
|
||||
if (action == "get") return json_out(api->batches->retrieve(id).raw);
|
||||
if (action == "create") {
|
||||
std::vector<core::BatchRequest> reqs;
|
||||
const Json* rs = body.find("requests");
|
||||
if (!rs || !rs->is_array()) bad("requests must be an array of {custom_id, params}");
|
||||
for (const Json& r : rs->as_array()) {
|
||||
const Json* p = r.find("params");
|
||||
if (!p || !p->is_object()) bad("every request needs params");
|
||||
reqs.push_back({text(r, "custom_id", true), request_from(*p)});
|
||||
}
|
||||
if (!confirmed(body)) {
|
||||
Json o = Json::object();
|
||||
o.set("requests", Json(static_cast<int>(reqs.size())));
|
||||
for (const core::BatchRequest& r : reqs) r.params.validate(core::kDefaultVersion);
|
||||
return json_out(dry_run("create a batch", o));
|
||||
}
|
||||
return json_out(api->batches->create(reqs, text(body, "user_profile_id")).raw);
|
||||
}
|
||||
if (action == "cancel" || action == "delete") {
|
||||
if (!confirmed(body)) {
|
||||
Json o = Json::object();
|
||||
o.set("id", Json(id));
|
||||
return json_out(dry_run(action + " the batch", o));
|
||||
}
|
||||
return json_out(action == "cancel" ? api->batches->cancel(id).raw : api->batches->destroy(id));
|
||||
}
|
||||
core::BatchResults res = api->batches->results(id);
|
||||
Json arr = Json::array();
|
||||
for (const core::BatchResultItem& it : res.items) arr.push(it.raw);
|
||||
Json o = Json::object();
|
||||
o.set("results", arr);
|
||||
o.set("truncated", Json(res.truncated));
|
||||
o.set("skipped_lines", Json(static_cast<int>(res.skipped_lines)));
|
||||
return json_out(o);
|
||||
});
|
||||
});
|
||||
|
||||
router.post("/ai/anthropic/files", "ai-anthropic-files", [api](fw::Request req) {
|
||||
Json body = parse_body(req);
|
||||
std::string action = text(body, "action", true);
|
||||
std::string id = text(body, "id");
|
||||
if (action != "list" && action != "get" && action != "delete" && action != "upload")
|
||||
bad("action must be list, get, delete or upload");
|
||||
if (action == "get" || action == "delete") {
|
||||
if (id.empty()) bad("id is required");
|
||||
need_id(id);
|
||||
}
|
||||
return guarded([&] {
|
||||
if (action == "list") return json_out(page_json(api->files->list(number(body, "limit", 0), text(body, "page"))));
|
||||
if (action == "get") return json_out(api->files->metadata(id).raw);
|
||||
if (action == "delete") {
|
||||
if (!confirmed(body)) {
|
||||
Json o = Json::object();
|
||||
o.set("id", Json(id));
|
||||
return json_out(dry_run("delete the file", o));
|
||||
}
|
||||
return json_out(api->files->destroy(id));
|
||||
}
|
||||
std::string name = text(body, "filename", true), data = text(body, "text", true);
|
||||
long expires = number(body, "expires_in_seconds", 0);
|
||||
if (!confirmed(body)) {
|
||||
Json o = Json::object();
|
||||
o.set("filename", Json(name));
|
||||
o.set("bytes", Json(static_cast<int>(data.size())));
|
||||
return json_out(dry_run("upload a text file", o));
|
||||
}
|
||||
return json_out(api->files->upload(name, data, "text/plain", expires).raw);
|
||||
});
|
||||
});
|
||||
|
||||
router.post("/ai/anthropic/skills", "ai-anthropic-skills", [api](fw::Request req) {
|
||||
Json body = parse_body(req);
|
||||
std::string action = text(body, "action", true);
|
||||
std::string id = text(body, "id");
|
||||
if (action != "list" && action != "get" && action != "versions" && action != "delete")
|
||||
bad("action must be list, get, versions or delete");
|
||||
if (action != "list") {
|
||||
if (id.empty()) bad("id is required");
|
||||
need_id(id);
|
||||
}
|
||||
return guarded([&] {
|
||||
if (action == "list") return json_out(page_json(api->skills->list(number(body, "limit", 0), text(body, "page"), text(body, "source"))));
|
||||
if (action == "get") return json_out(api->skills->retrieve(id));
|
||||
if (action == "versions") return json_out(page_json(api->skills->list_versions(id, number(body, "limit", 0))));
|
||||
if (!confirmed(body)) {
|
||||
Json o = Json::object();
|
||||
o.set("id", Json(id));
|
||||
return json_out(dry_run("delete the skill and all its versions", o));
|
||||
}
|
||||
return json_out(api->skills->destroy(id));
|
||||
});
|
||||
});
|
||||
|
||||
router.post("/ai/anthropic/profiles", "ai-anthropic-profiles", [api](fw::Request req) {
|
||||
Json body = parse_body(req);
|
||||
std::string action = text(body, "action", true);
|
||||
std::string id = text(body, "id");
|
||||
if (action != "list" && action != "get" && action != "delete") bad("action must be list, get or delete");
|
||||
if (action != "list") {
|
||||
if (id.empty()) bad("id is required");
|
||||
need_id(id);
|
||||
}
|
||||
return guarded([&] {
|
||||
if (action == "list") return json_out(page_json(api->user_profiles->list(number(body, "limit", 0), text(body, "page"))));
|
||||
if (action == "get") return json_out(api->user_profiles->retrieve(id));
|
||||
if (!confirmed(body)) {
|
||||
Json o = Json::object();
|
||||
o.set("id", Json(id));
|
||||
return json_out(dry_run("delete the user profile", o));
|
||||
}
|
||||
return json_out(api->user_profiles->destroy(id));
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
} // namespace molo::example::app
|
||||
|
||||
@@ -0,0 +1,52 @@
|
||||
// Anthropic page: thin client over /ai/anthropic/* (all limits server side).
|
||||
(function () {
|
||||
"use strict";
|
||||
var $ = function (id) { return document.getElementById(id); };
|
||||
var out = $("an-out"), err = $("an-error");
|
||||
|
||||
var templates = {
|
||||
build: { model: "claude-opus-5-5", max_tokens: 1024, prompt: "Hello, Claude",
|
||||
tools: [{ type: "web_search_20260318", max_uses: 2 }], thinking: { type: "adaptive" } },
|
||||
count: { model: "claude-opus-5-5", prompt: "Hello, Claude" },
|
||||
messages: { model: "claude-opus-5-5", max_tokens: 256, prompt: "Hello, Claude", confirm: false },
|
||||
stream: { model: "claude-opus-5-5", max_tokens: 256, prompt: "Hello, Claude", confirm: false },
|
||||
models: { limit: 5 },
|
||||
batches: { action: "list" },
|
||||
files: { action: "list" },
|
||||
skills: { action: "list" },
|
||||
profiles: { action: "list" }
|
||||
};
|
||||
|
||||
function fill() { $("an-body").value = JSON.stringify(templates[$("an-route").value], null, 1); }
|
||||
|
||||
function send() {
|
||||
var body;
|
||||
try { body = JSON.parse($("an-body").value || "{}"); }
|
||||
catch (e) { err.textContent = "Body is not valid JSON"; return; }
|
||||
err.textContent = "";
|
||||
out.textContent = "...";
|
||||
fetch("/ai/anthropic/" + $("an-route").value, {
|
||||
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 = ""; });
|
||||
}
|
||||
|
||||
fetch("/ai/anthropic/status").then(function (r) { return r.json(); }).then(function (s) {
|
||||
$("an-config").textContent = s.configured
|
||||
? "Credential found (" + s.key_env + "). API version " + s.default_version + "."
|
||||
: "No credential: calls answer 503 until " + s.key_env + " is set. Build still works.";
|
||||
});
|
||||
|
||||
$("an-route").onchange = fill;
|
||||
$("an-reset").onclick = fill;
|
||||
$("an-send").onclick = send;
|
||||
fill();
|
||||
})();
|
||||
Reference in New Issue
Block a user