feat(clients): xai core: Responses, chat, tools, media, batch, models, ChatModel
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
+660
-3
@@ -1,13 +1,670 @@
|
||||
#include "../AiDemos.hpp"
|
||||
|
||||
#include <functional>
|
||||
|
||||
#include "../../fw/Router.hpp"
|
||||
#include "../../fw/Templates.hpp"
|
||||
#include "llm/config.h"
|
||||
#include "xai/core/client.h"
|
||||
|
||||
namespace molo::example::app {
|
||||
|
||||
// xAI Grok: chat, responses, tools, media, batch, models. Stub: the module agent fills this in.
|
||||
// xAI Grok core platform over the real src/xai/core part. GET routes need no
|
||||
// credential. Every route that calls xAI is a POST: 503 not_configured without
|
||||
// XAI_API_KEY, 422 on bad input (validated locally, before the credential
|
||||
// check). Media generation, batch submission, deletes and cancels are dry runs
|
||||
// that return the validated wire body unless the body says "confirm":true.
|
||||
|
||||
namespace {
|
||||
|
||||
namespace xc = xai::core;
|
||||
using Json = clients::body::Json;
|
||||
|
||||
constexpr std::size_t kMaxBody = 256 * 1024;
|
||||
|
||||
const char kPage[] = R"XAI({% extends "base.html" %}
|
||||
{% block content %}
|
||||
<h1>xAI Grok</h1>
|
||||
<p class="hint">Responses, chat, tools, images, video, embeddings, models and batches over api.x.ai.
|
||||
Paid calls are dry runs until you tick confirm.</p>
|
||||
<p id="xai-config" class="hint">Checking XAI_API_KEY...</p>
|
||||
<section class="xai">
|
||||
<label>Prompt <textarea id="xai-prompt" rows="3" maxlength="8000">Say hello in one sentence.</textarea></label>
|
||||
<label>Model <input id="xai-model" type="text" maxlength="128" placeholder="model id (see Models)"></label>
|
||||
<label>Tools
|
||||
<select id="xai-tools">
|
||||
<option value="">none</option>
|
||||
<option value="web_search">web search</option>
|
||||
<option value="x_search">X search</option>
|
||||
<option value="code_interpreter">code execution</option>
|
||||
<option value="web_search,x_search">web + X search</option>
|
||||
</select></label>
|
||||
<label>Reasoning effort
|
||||
<select id="xai-effort"><option value="">default</option><option>low</option><option>medium</option><option>high</option><option>xhigh</option></select></label>
|
||||
<div class="xai-actions">
|
||||
<button id="xai-chat" type="button" class="primary">Ask (Responses)</button>
|
||||
<button id="xai-models" type="button">Models</button>
|
||||
<button id="xai-account" type="button">API key</button>
|
||||
</div>
|
||||
<h2>More calls</h2>
|
||||
<label>Call
|
||||
<select id="xai-route">
|
||||
<option value="chat">Chat completions</option>
|
||||
<option value="messages">Anthropic messages</option>
|
||||
<option value="responses/get">Get stored response</option>
|
||||
<option value="responses/delete">Delete stored response</option>
|
||||
<option value="images">Image generate / edit</option>
|
||||
<option value="videos">Video (async)</option>
|
||||
<option value="embeddings">Embeddings</option>
|
||||
<option value="tokenize">Tokenize</option>
|
||||
<option value="models">Models</option>
|
||||
<option value="batches">Batches</option>
|
||||
<option value="account">Account</option>
|
||||
</select></label>
|
||||
<label>Body (JSON object) <textarea id="xai-body" rows="5">{}</textarea></label>
|
||||
<label class="xai-confirm"><input id="xai-confirm" type="checkbox"> confirm (run paid or destructive calls)</label>
|
||||
<div class="xai-actions"><button id="xai-send" type="button">Send</button></div>
|
||||
<p id="xai-error" class="error" role="alert"></p>
|
||||
<pre id="xai-out" class="xai-out"></pre>
|
||||
</section>
|
||||
<style>
|
||||
.xai label{display:block;margin:.5rem 0}
|
||||
.xai input[type=text],.xai textarea,.xai select{width:100%;box-sizing:border-box}
|
||||
.xai-actions{display:flex;flex-wrap:wrap;gap:.5rem;margin:.5rem 0}
|
||||
.xai-out{overflow:auto;max-height:24rem;white-space:pre-wrap;word-break:break-word}
|
||||
</style>
|
||||
<script src="/embedded/ai_xai_core.js"></script>
|
||||
{% endblock %}
|
||||
)XAI";
|
||||
|
||||
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() == "INVALID_ARGUMENT" && e.http_status() == 400) bad(e.message());
|
||||
throw fw::HttpError(502, "xai_error", e.type() + ": " + e.message());
|
||||
}
|
||||
|
||||
template <typename F>
|
||||
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& b, const char* key, bool required = false) {
|
||||
const Json* v = b.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();
|
||||
}
|
||||
|
||||
std::optional<int> number(const Json& b, const char* key) {
|
||||
const Json* v = b.find(key);
|
||||
if (!v || v->is_null()) return std::nullopt;
|
||||
if (!v->is_number()) bad(std::string(key) + " must be a number");
|
||||
return static_cast<int>(v->as_int());
|
||||
}
|
||||
|
||||
bool flag(const Json& b, const char* key) {
|
||||
const Json* v = b.find(key);
|
||||
if (!v || v->is_null()) return false;
|
||||
if (!v->is_bool()) bad(std::string(key) + " must be a boolean");
|
||||
return v->as_bool();
|
||||
}
|
||||
|
||||
std::string pick(const Json& b, const char* key, std::initializer_list<const char*> allowed) {
|
||||
std::string v = text(b, key, true);
|
||||
for (const char* a : allowed)
|
||||
if (v == a) return v;
|
||||
bad(std::string(key) + " is not one of the allowed values");
|
||||
}
|
||||
|
||||
std::vector<std::string> string_list(const Json& b, const char* key) {
|
||||
std::vector<std::string> out;
|
||||
const Json* v = b.find(key);
|
||||
if (!v || v->is_null()) return out;
|
||||
if (!v->is_array()) bad(std::string(key) + " must be an array");
|
||||
for (const Json& e : v->as_array()) {
|
||||
if (!e.is_string()) bad(std::string(key) + " must hold strings");
|
||||
out.push_back(e.as_string());
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
Json dry_run(const Json& wire, const std::string& what) {
|
||||
Json o = Json::object();
|
||||
o.set("dry_run", Json(true));
|
||||
o.set("would_send", Json(what));
|
||||
o.set("body", wire);
|
||||
o.set("hint", Json("send confirm:true to run it"));
|
||||
return o;
|
||||
}
|
||||
|
||||
Json usage_json(const xc::TokenUsage& u) {
|
||||
Json o = Json::object();
|
||||
o.set("input_tokens", Json(u.input_tokens));
|
||||
o.set("output_tokens", Json(u.output_tokens));
|
||||
o.set("total_tokens", Json(u.total_tokens));
|
||||
o.set("cached_tokens", Json(u.cached_tokens));
|
||||
o.set("reasoning_tokens", Json(u.reasoning_tokens));
|
||||
o.set("cost_usd_ticks", Json(u.cost_usd_ticks));
|
||||
o.set("cost_usd", Json(u.cost_usd()));
|
||||
return o;
|
||||
}
|
||||
|
||||
Json response_json(const xc::ModelResponse& r) {
|
||||
Json o = Json::object();
|
||||
o.set("id", Json(r.id()));
|
||||
o.set("model", Json(r.model()));
|
||||
o.set("status", Json(r.status()));
|
||||
o.set("text", Json(r.text()));
|
||||
if (!r.reasoning_text().empty()) o.set("reasoning", Json(r.reasoning_text()));
|
||||
Json cites = Json::array();
|
||||
for (const auto& c : r.citations()) cites.push(Json(c.url));
|
||||
o.set("citations", cites);
|
||||
Json calls = Json::array();
|
||||
for (const auto& c : r.function_calls()) {
|
||||
Json cj = Json::object();
|
||||
cj.set("call_id", Json(c.call_id()));
|
||||
cj.set("name", Json(c.name()));
|
||||
cj.set("arguments", c.arguments());
|
||||
calls.push(cj);
|
||||
}
|
||||
o.set("function_calls", calls);
|
||||
o.set("server_tool_calls", Json(static_cast<int>(r.server_tool_calls().size())));
|
||||
o.set("usage", usage_json(r.usage()));
|
||||
return o;
|
||||
}
|
||||
|
||||
Json model_json(const xc::ModelInfo& m) {
|
||||
Json o = Json::object();
|
||||
o.set("id", Json(m.id));
|
||||
o.set("aliases", xc::jx::string_array(m.aliases));
|
||||
o.set("input_modalities", xc::jx::string_array(m.input_modalities));
|
||||
o.set("output_modalities", xc::jx::string_array(m.output_modalities));
|
||||
o.set("reasoning_effort", xc::jx::string_array(m.reasoning_efforts));
|
||||
Json prices = Json::object();
|
||||
for (const auto& [k, v] : m.prices) prices.set(k, Json(static_cast<double>(v)));
|
||||
o.set("prices", prices);
|
||||
return o;
|
||||
}
|
||||
|
||||
Json batch_json(const xc::Batch& b) {
|
||||
Json o = Json::object();
|
||||
o.set("batch_id", Json(b.batch_id));
|
||||
o.set("name", Json(b.name));
|
||||
o.set("finished", Json(b.finished()));
|
||||
Json s = Json::object();
|
||||
s.set("num_requests", Json(b.state.num_requests));
|
||||
s.set("num_pending", Json(b.state.num_pending));
|
||||
s.set("num_success", Json(b.state.num_success));
|
||||
s.set("num_error", Json(b.state.num_error));
|
||||
s.set("num_cancelled", Json(b.state.num_cancelled));
|
||||
o.set("state", s);
|
||||
return o;
|
||||
}
|
||||
|
||||
xc::ResponseRequest build_response(const Json& b) {
|
||||
std::string model = text(b, "model", true);
|
||||
xc::ResponseRequest r(model);
|
||||
r.input_text(text(b, "prompt", true));
|
||||
if (std::string i = text(b, "instructions"); !i.empty()) r.instructions(i);
|
||||
r.store(false);
|
||||
if (std::string e = text(b, "effort"); !e.empty()) r.reasoning_effort(e);
|
||||
if (auto n = number(b, "maxOutputTokens")) r.max_output_tokens(*n);
|
||||
for (const std::string& t : string_list(b, "tools")) {
|
||||
if (t == "web_search") r.add_tool(xc::WebSearchTool());
|
||||
else if (t == "x_search") r.add_tool(xc::XSearchTool());
|
||||
else if (t == "code_interpreter") r.add_tool(xc::CodeExecutionTool());
|
||||
else bad("tools may hold web_search, x_search, code_interpreter");
|
||||
}
|
||||
return r;
|
||||
}
|
||||
|
||||
xc::ImageOptions image_options(const Json& b) {
|
||||
xc::ImageOptions o;
|
||||
o.model = text(b, "model");
|
||||
if (auto n = number(b, "n")) o.n = *n;
|
||||
o.aspect_ratio = text(b, "aspectRatio");
|
||||
o.resolution = text(b, "resolution");
|
||||
o.response_format = text(b, "responseFormat");
|
||||
return o;
|
||||
}
|
||||
|
||||
class Routes {
|
||||
public:
|
||||
Routes() = default;
|
||||
|
||||
static std::shared_ptr<xc::XaiClient> client() { return xc::XaiClient::from_env(); }
|
||||
|
||||
static fw::Response chat(const fw::Request& req) {
|
||||
Json b = parse_body(req);
|
||||
std::string wire = text(b, "wire");
|
||||
if (!wire.empty() && wire != "responses" && wire != "chat") bad("wire must be responses or chat");
|
||||
xc::ResponseRequest r = build_response(b);
|
||||
xc::ChatRequest cr(text(b, "model", true));
|
||||
if (wire == "chat") {
|
||||
cr.add(xc::ChatMessage::user(text(b, "prompt", true)));
|
||||
if (std::string e = text(b, "effort"); !e.empty()) cr.reasoning_effort(e);
|
||||
if (auto n = number(b, "maxOutputTokens")) cr.max_completion_tokens(*n);
|
||||
cr.to_json(); // validate
|
||||
} else {
|
||||
r.to_json();
|
||||
}
|
||||
return guarded([&] {
|
||||
auto c = client();
|
||||
if (wire == "chat") {
|
||||
xc::ChatCompletion done = c->chat.create(cr);
|
||||
Json o = Json::object();
|
||||
o.set("id", Json(done.id));
|
||||
o.set("text", Json(done.text()));
|
||||
o.set("finish_reason", Json(done.finish_reason()));
|
||||
o.set("usage", usage_json(done.usage));
|
||||
return json_out(o);
|
||||
}
|
||||
return json_out(response_json(c->responses.create(r)));
|
||||
});
|
||||
}
|
||||
|
||||
static fw::Response messages(const fw::Request& req) {
|
||||
Json b = parse_body(req);
|
||||
xc::MessagesRequest r(text(b, "model", true), number(b, "maxTokens").value_or(256));
|
||||
r.user(text(b, "prompt", true));
|
||||
r.to_json();
|
||||
return guarded([&] {
|
||||
xc::MessagesResponse m = client()->messages.create(r);
|
||||
Json o = Json::object();
|
||||
o.set("id", Json(m.id));
|
||||
o.set("text", Json(m.text()));
|
||||
o.set("stop_reason", Json(m.stop_reason));
|
||||
o.set("input_tokens", Json(m.input_tokens));
|
||||
o.set("output_tokens", Json(m.output_tokens));
|
||||
return json_out(o);
|
||||
});
|
||||
}
|
||||
|
||||
static fw::Response response_get(const fw::Request& req) {
|
||||
Json b = parse_body(req);
|
||||
std::string id = text(b, "id", true);
|
||||
xc::render(xc::Call::kResponsesGet, {id});
|
||||
std::string action = text(b, "action");
|
||||
if (!action.empty() && action != "get" && action != "items") bad("action must be get or items");
|
||||
return guarded([&] {
|
||||
auto c = client();
|
||||
if (action == "items") {
|
||||
xc::InputItemList l = c->responses.all_input_items(id, 200);
|
||||
Json o = Json::object();
|
||||
Json arr = Json::array();
|
||||
for (const Json& i : l.data) arr.push(i);
|
||||
o.set("items", arr);
|
||||
o.set("truncated", Json(l.truncated));
|
||||
return json_out(o);
|
||||
}
|
||||
return json_out(response_json(c->responses.retrieve(id)));
|
||||
});
|
||||
}
|
||||
|
||||
static fw::Response response_delete(const fw::Request& req) {
|
||||
Json b = parse_body(req);
|
||||
std::string id = text(b, "id", true);
|
||||
xc::render(xc::Call::kResponsesDelete, {id});
|
||||
if (!flag(b, "confirm")) {
|
||||
Json o = Json::object();
|
||||
o.set("dry_run", Json(true));
|
||||
o.set("would_delete", Json(id));
|
||||
return json_out(o);
|
||||
}
|
||||
return guarded([&] {
|
||||
xc::DeletedResponse d = client()->responses.remove(id);
|
||||
Json o = Json::object();
|
||||
o.set("id", Json(d.id));
|
||||
o.set("deleted", Json(d.deleted));
|
||||
return json_out(o);
|
||||
});
|
||||
}
|
||||
|
||||
static fw::Response images(const fw::Request& req) {
|
||||
Json b = parse_body(req);
|
||||
std::string action = pick(b, "action", {"generate", "edit", "poll"});
|
||||
if (action == "poll") {
|
||||
std::string id = text(b, "requestId", true);
|
||||
xc::render(xc::Call::kImagesGet, {id});
|
||||
return guarded([&] {
|
||||
xc::DeferredImage d = client()->images.poll(id);
|
||||
Json o = Json::object();
|
||||
o.set("status", Json(d.status));
|
||||
Json urls = Json::array();
|
||||
if (d.result)
|
||||
for (const auto& g : d.result->data) urls.push(Json(g.url));
|
||||
o.set("urls", urls);
|
||||
return json_out(o);
|
||||
});
|
||||
}
|
||||
Json wire;
|
||||
xc::ImageGenerationRequest gen;
|
||||
xc::ImageEditRequest edit;
|
||||
if (action == "generate") {
|
||||
gen.prompt = text(b, "prompt", true);
|
||||
gen.options = image_options(b);
|
||||
wire = gen.to_json();
|
||||
} else {
|
||||
edit.prompt = text(b, "prompt", true);
|
||||
edit.image = xc::MediaSource::image_url(text(b, "imageUrl", true));
|
||||
edit.options = image_options(b);
|
||||
wire = edit.to_json();
|
||||
}
|
||||
if (!flag(b, "confirm")) return json_out(dry_run(wire, action == "generate" ? "/v1/images/generations" : "/v1/images/edits"));
|
||||
return guarded([&] {
|
||||
xc::ImageResult r = action == "generate" ? client()->images.generate(gen) : client()->images.edit(edit);
|
||||
Json o = Json::object();
|
||||
Json urls = Json::array();
|
||||
for (const auto& g : r.data) urls.push(Json(g.url.empty() ? "(base64 payload omitted)" : g.url));
|
||||
o.set("urls", urls);
|
||||
o.set("cost_usd", Json(r.usage.cost_usd()));
|
||||
return json_out(o);
|
||||
});
|
||||
}
|
||||
|
||||
static fw::Response videos(const fw::Request& req) {
|
||||
Json b = parse_body(req);
|
||||
std::string action = pick(b, "action", {"generate", "edit", "extend", "poll"});
|
||||
if (action == "poll") {
|
||||
std::string id = text(b, "requestId", true);
|
||||
xc::render(xc::Call::kVideosGet, {id});
|
||||
return guarded([&] {
|
||||
xc::VideoJob j = client()->videos.poll(id);
|
||||
Json o = Json::object();
|
||||
o.set("status", Json(j.status));
|
||||
if (j.progress) o.set("progress", Json(static_cast<double>(*j.progress)));
|
||||
if (j.video) o.set("url", Json(j.video->url));
|
||||
if (j.error) o.set("error", Json(j.error->code + ": " + j.error->message));
|
||||
return json_out(o);
|
||||
});
|
||||
}
|
||||
xc::VideoGenerationRequest gen;
|
||||
xc::VideoEditRequest edit;
|
||||
xc::VideoExtendRequest ext;
|
||||
Json wire;
|
||||
if (action == "generate") {
|
||||
gen.model = text(b, "model");
|
||||
gen.prompt = text(b, "prompt");
|
||||
gen.duration = number(b, "duration");
|
||||
gen.aspect_ratio = text(b, "aspectRatio");
|
||||
gen.resolution = text(b, "resolution");
|
||||
if (std::string u = text(b, "imageUrl"); !u.empty()) gen.image = xc::MediaSource::image_url(u);
|
||||
wire = gen.to_json();
|
||||
} else if (action == "edit") {
|
||||
edit.model = text(b, "model");
|
||||
edit.prompt = text(b, "prompt", true);
|
||||
edit.video = xc::MediaSource::video_url(text(b, "videoUrl", true));
|
||||
wire = edit.to_json();
|
||||
} else {
|
||||
ext.model = text(b, "model");
|
||||
ext.prompt = text(b, "prompt", true);
|
||||
ext.video = xc::MediaSource::video_url(text(b, "videoUrl", true));
|
||||
ext.duration = number(b, "duration");
|
||||
wire = ext.to_json();
|
||||
}
|
||||
if (!flag(b, "confirm")) return json_out(dry_run(wire, "/v1/videos/" + std::string(action == "generate" ? "generations" : action == "edit" ? "edits" : "extensions")));
|
||||
return guarded([&] {
|
||||
auto c = client();
|
||||
std::string id = action == "generate" ? c->videos.start_generate(gen)
|
||||
: action == "edit" ? c->videos.start_edit(edit)
|
||||
: c->videos.start_extend(ext);
|
||||
Json o = Json::object();
|
||||
o.set("request_id", Json(id));
|
||||
o.set("hint", Json("poll with action poll"));
|
||||
return json_out(o, 202);
|
||||
});
|
||||
}
|
||||
|
||||
static fw::Response embeddings(const fw::Request& req) {
|
||||
Json b = parse_body(req);
|
||||
xc::EmbeddingRequest r;
|
||||
r.model = text(b, "model", true);
|
||||
r.texts = string_list(b, "texts");
|
||||
r.dimensions = number(b, "dimensions");
|
||||
r.to_json();
|
||||
return guarded([&] {
|
||||
xc::EmbeddingResult e = client()->embeddings.embed(r);
|
||||
Json o = Json::object();
|
||||
Json arr = Json::array();
|
||||
for (const auto& v : e.data) {
|
||||
Json row = Json::object();
|
||||
row.set("index", Json(v.index));
|
||||
row.set("dimensions", Json(static_cast<double>(v.values.size())));
|
||||
arr.push(row);
|
||||
}
|
||||
o.set("embeddings", arr);
|
||||
o.set("prompt_tokens", Json(e.prompt_tokens));
|
||||
return json_out(o);
|
||||
});
|
||||
}
|
||||
|
||||
static fw::Response tokenize(const fw::Request& req) {
|
||||
Json b = parse_body(req);
|
||||
std::string model = text(b, "model", true);
|
||||
std::string t = text(b, "text", true);
|
||||
xc::Check::model(model);
|
||||
xc::Check::text("text", t, xc::Caps::kMaxTokenizeBytes);
|
||||
return guarded([&] {
|
||||
auto toks = client()->tokenizer.tokenize(model, t);
|
||||
Json arr = Json::array();
|
||||
for (const auto& k : toks) {
|
||||
Json row = Json::object();
|
||||
row.set("token_id", Json(k.token_id));
|
||||
row.set("token", Json(k.string_token));
|
||||
arr.push(row);
|
||||
}
|
||||
Json o = Json::object();
|
||||
o.set("count", Json(static_cast<double>(toks.size())));
|
||||
o.set("tokens", arr);
|
||||
return json_out(o);
|
||||
});
|
||||
}
|
||||
|
||||
static fw::Response models(const fw::Request& req) {
|
||||
Json b = parse_body(req);
|
||||
std::string kind = text(b, "kind");
|
||||
if (kind.empty()) kind = "language";
|
||||
pick_kind(kind);
|
||||
std::string id = text(b, "id");
|
||||
if (!id.empty()) xc::Check::id("model", id);
|
||||
return guarded([&] {
|
||||
auto c = client();
|
||||
xc::ModelKind k = kind_of(kind);
|
||||
if (!id.empty()) return json_out(model_json(c->models.get(k, id)));
|
||||
xc::ModelList l = c->models.list(k);
|
||||
Json arr = Json::array();
|
||||
for (const auto& m : l.models) arr.push(model_json(m));
|
||||
Json o = Json::object();
|
||||
o.set("models", arr);
|
||||
o.set("truncated", Json(l.truncated));
|
||||
return json_out(o);
|
||||
});
|
||||
}
|
||||
|
||||
static fw::Response batches(const fw::Request& req) {
|
||||
Json b = parse_body(req);
|
||||
std::string action = pick(b, "action", {"create", "list", "get", "add", "requests", "results", "cancel"});
|
||||
std::string id = text(b, "batchId");
|
||||
if (action != "create" && action != "list") {
|
||||
id = text(b, "batchId", true);
|
||||
xc::render(xc::Call::kBatchGet, {id});
|
||||
}
|
||||
std::string name = action == "create" ? text(b, "name", true) : "";
|
||||
std::vector<xc::BatchEntry> entries;
|
||||
if (action == "add") {
|
||||
std::string model = text(b, "model", true);
|
||||
for (const std::string& p : string_list(b, "prompts")) {
|
||||
xc::ChatRequest cr(model);
|
||||
cr.add(xc::ChatMessage::user(p));
|
||||
entries.push_back(xc::BatchEntry::chat("req_" + std::to_string(entries.size() + 1), cr));
|
||||
}
|
||||
if (entries.empty()) bad("prompts is required");
|
||||
if (entries.size() > xc::Caps::kMaxBatchRequestsPerAdd) bad("too many prompts");
|
||||
}
|
||||
if (name.size() > xc::Caps::kMaxNameLen) bad("name too long");
|
||||
bool confirm = flag(b, "confirm");
|
||||
if ((action == "add" || action == "cancel") && !confirm) {
|
||||
Json o = Json::object();
|
||||
o.set("dry_run", Json(true));
|
||||
o.set("would", Json(action));
|
||||
o.set("batch_id", Json(id));
|
||||
o.set("requests", Json(static_cast<double>(entries.size())));
|
||||
return json_out(o);
|
||||
}
|
||||
return guarded([&] {
|
||||
auto c = client();
|
||||
if (action == "create") return json_out(batch_json(c->batches.create(name)), 201);
|
||||
if (action == "get") return json_out(batch_json(c->batches.get(id)));
|
||||
if (action == "add") return json_out(batch_json(c->batches.add_requests(id, entries)));
|
||||
if (action == "cancel") return json_out(batch_json(c->batches.cancel(id)));
|
||||
Json o = Json::object();
|
||||
if (action == "list") {
|
||||
Json arr = Json::array();
|
||||
for (const auto& x : c->batches.list(20).batches) arr.push(batch_json(x));
|
||||
o.set("batches", arr);
|
||||
} else if (action == "requests") {
|
||||
Json arr = Json::array();
|
||||
for (const auto& r : c->batches.list_requests(id, 100).requests) {
|
||||
Json row = Json::object();
|
||||
row.set("id", Json(r.batch_request_id));
|
||||
row.set("state", Json(r.state));
|
||||
arr.push(row);
|
||||
}
|
||||
o.set("requests", arr);
|
||||
} else {
|
||||
xc::BatchResultSet set = c->batches.all_results(id, 200);
|
||||
Json arr = Json::array();
|
||||
for (const auto& r : set.results) {
|
||||
Json row = Json::object();
|
||||
row.set("id", Json(r.batch_request_id));
|
||||
row.set("ok", Json(r.succeeded));
|
||||
if (!r.error.empty()) row.set("error", Json(r.error));
|
||||
arr.push(row);
|
||||
}
|
||||
o.set("results", arr);
|
||||
o.set("truncated", Json(set.truncated));
|
||||
}
|
||||
return json_out(o);
|
||||
});
|
||||
}
|
||||
|
||||
static fw::Response account(const fw::Request& req) {
|
||||
Json b = parse_body(req);
|
||||
std::string action = pick(b, "action", {"api_key", "me"});
|
||||
return guarded([&] {
|
||||
auto c = client();
|
||||
Json o = Json::object();
|
||||
if (action == "api_key") {
|
||||
xc::ApiKeyInfo k = c->account.api_key();
|
||||
o.set("name", Json(k.name));
|
||||
o.set("redacted_api_key", Json(k.redacted_api_key));
|
||||
o.set("usable", Json(k.usable()));
|
||||
o.set("acls", xc::jx::string_array(k.acls));
|
||||
} else {
|
||||
xc::MeInfo m = c->account.me();
|
||||
o.set("team_id", Json(m.team_id));
|
||||
o.set("user_id", Json(m.user_id));
|
||||
o.set("zdr_status", Json(m.zdr_status));
|
||||
o.set("team_blocked", Json(m.team_blocked));
|
||||
}
|
||||
return json_out(o);
|
||||
});
|
||||
}
|
||||
|
||||
private:
|
||||
static void pick_kind(const std::string& k) {
|
||||
if (k != "generic" && k != "language" && k != "image" && k != "video" && k != "embedding")
|
||||
bad("kind must be generic, language, image, video or embedding");
|
||||
}
|
||||
static xc::ModelKind kind_of(const std::string& k) {
|
||||
if (k == "language") return xc::ModelKind::kLanguage;
|
||||
if (k == "image") return xc::ModelKind::kImage;
|
||||
if (k == "video") return xc::ModelKind::kVideo;
|
||||
if (k == "embedding") return xc::ModelKind::kEmbedding;
|
||||
return xc::ModelKind::kGeneric;
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace
|
||||
|
||||
void register_ai_xai_demo(fw::Router& router, Services& services) {
|
||||
(void)router;
|
||||
(void)services;
|
||||
fw::Environment* env = services.templates.get();
|
||||
services.templates->add_template("ai_xai.html", kPage);
|
||||
services.add_feature("ai-xai", "/ai/xai");
|
||||
|
||||
router.get("/ai/xai", "ai-xai-page", [env](fw::Request req) {
|
||||
(void)req;
|
||||
fw::TemplateCtx ctx;
|
||||
ctx["title"] = std::string("xAI Grok");
|
||||
return fw::Response(200, env->render("ai_xai.html", ctx), "text/html; charset=utf-8");
|
||||
});
|
||||
|
||||
router.get("/ai/xai/status", "ai-xai-status", [](fw::Request req) {
|
||||
(void)req;
|
||||
Json o = Json::object();
|
||||
o.set("configured", Json(!llm::Config::get(xc::XaiService::kKeyEnv).empty()));
|
||||
o.set("key_env", Json(xc::XaiService::kKeyEnv));
|
||||
o.set("base_url", Json(xc::XaiService::kBaseUrl));
|
||||
o.set("calls", Json(static_cast<double>(xc::call_count())));
|
||||
return json_out(o);
|
||||
});
|
||||
|
||||
// The spec-checked call table, for humans.
|
||||
router.get("/ai/xai/calls", "ai-xai-calls", [](fw::Request req) {
|
||||
(void)req;
|
||||
Json arr = Json::array();
|
||||
for (std::size_t i = 0; i < xc::call_count(); ++i) {
|
||||
const xc::CallSpec& s = xc::spec_at(i);
|
||||
Json row = Json::object();
|
||||
row.set("http", Json(s.http_method));
|
||||
row.set("path", Json(s.path));
|
||||
row.set("op", Json(s.op_id));
|
||||
row.set("source", Json(s.source));
|
||||
arr.push(row);
|
||||
}
|
||||
Json o = Json::object();
|
||||
o.set("calls", arr);
|
||||
return json_out(o);
|
||||
});
|
||||
|
||||
router.post("/ai/xai/chat", "ai-xai-chat", [](fw::Request r) { return guarded([&] { return Routes::chat(r); }); });
|
||||
router.post("/ai/xai/messages", "ai-xai-messages", [](fw::Request r) { return guarded([&] { return Routes::messages(r); }); });
|
||||
router.post("/ai/xai/responses/get", "ai-xai-response-get", [](fw::Request r) { return guarded([&] { return Routes::response_get(r); }); });
|
||||
router.post("/ai/xai/responses/delete", "ai-xai-response-delete", [](fw::Request r) { return guarded([&] { return Routes::response_delete(r); }); });
|
||||
router.post("/ai/xai/images", "ai-xai-images", [](fw::Request r) { return guarded([&] { return Routes::images(r); }); });
|
||||
router.post("/ai/xai/videos", "ai-xai-videos", [](fw::Request r) { return guarded([&] { return Routes::videos(r); }); });
|
||||
router.post("/ai/xai/embeddings", "ai-xai-embeddings", [](fw::Request r) { return guarded([&] { return Routes::embeddings(r); }); });
|
||||
router.post("/ai/xai/tokenize", "ai-xai-tokenize", [](fw::Request r) { return guarded([&] { return Routes::tokenize(r); }); });
|
||||
router.post("/ai/xai/models", "ai-xai-models", [](fw::Request r) { return guarded([&] { return Routes::models(r); }); });
|
||||
router.post("/ai/xai/batches", "ai-xai-batches", [](fw::Request r) { return guarded([&] { return Routes::batches(r); }); });
|
||||
router.post("/ai/xai/account", "ai-xai-account", [](fw::Request r) { return guarded([&] { return Routes::account(r); }); });
|
||||
}
|
||||
|
||||
} // namespace molo::example::app
|
||||
|
||||
@@ -0,0 +1,53 @@
|
||||
// xAI Grok page: thin client over /ai/xai/* (all limits are enforced server side).
|
||||
(function () {
|
||||
"use strict";
|
||||
var $ = function (id) { return document.getElementById(id); };
|
||||
var out = $("xai-out"), err = $("xai-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 = (j.text !== undefined && !j.dry_run) ? j.text + "\n\n" + JSON.stringify(j, null, 2)
|
||||
: JSON.stringify(j, null, 2);
|
||||
}
|
||||
});
|
||||
}).catch(function (e) { err.textContent = String(e); out.textContent = ""; });
|
||||
}
|
||||
|
||||
fetch("/ai/xai/status").then(function (r) { return r.json(); }).then(function (s) {
|
||||
$("xai-config").textContent = s.configured
|
||||
? "XAI_API_KEY found. " + s.calls + " calls are covered."
|
||||
: "No XAI_API_KEY: calls answer 503 until one is configured.";
|
||||
});
|
||||
|
||||
$("xai-chat").onclick = function () {
|
||||
var tools = $("xai-tools").value;
|
||||
post("/ai/xai/chat", {
|
||||
model: $("xai-model").value.trim(),
|
||||
prompt: $("xai-prompt").value,
|
||||
effort: $("xai-effort").value,
|
||||
tools: tools ? tools.split(",") : []
|
||||
});
|
||||
};
|
||||
$("xai-models").onclick = function () { post("/ai/xai/models", { kind: "language" }); };
|
||||
$("xai-account").onclick = function () { post("/ai/xai/account", { action: "api_key" }); };
|
||||
$("xai-send").onclick = function () {
|
||||
var body;
|
||||
try { body = JSON.parse($("xai-body").value || "{}"); }
|
||||
catch (e) { err.textContent = "Body is not valid JSON"; return; }
|
||||
if ($("xai-confirm").checked) body.confirm = true;
|
||||
post("/ai/xai/" + $("xai-route").value, body);
|
||||
};
|
||||
})();
|
||||
Reference in New Issue
Block a user