feat(clients): meta: Meta Model API module, Muse Code protocol client, demo and tests
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
@@ -0,0 +1,293 @@
|
||||
#include "meta/chat_completions.h"
|
||||
|
||||
#include "meta/calls.h"
|
||||
#include "meta/caps.h"
|
||||
#include "meta/check.h"
|
||||
#include "meta/schema_check.h"
|
||||
|
||||
namespace molo::meta {
|
||||
|
||||
namespace {
|
||||
Json msg(const char* role, const Json& content) {
|
||||
Json o = Json::object();
|
||||
o.set("role", Json(role));
|
||||
o.set("content", content);
|
||||
return o;
|
||||
}
|
||||
Json part(const char* type) {
|
||||
Json o = Json::object();
|
||||
o.set("type", Json(type));
|
||||
return o;
|
||||
}
|
||||
} // namespace
|
||||
|
||||
Json ChatMessage::developer(const std::string& t) { return msg("developer", Json(t)); }
|
||||
Json ChatMessage::system(const std::string& t) { return msg("system", Json(t)); }
|
||||
Json ChatMessage::user(const std::string& t) { return msg("user", Json(t)); }
|
||||
|
||||
Json ChatMessage::user_parts(const std::vector<Json>& parts) {
|
||||
Json a = Json::array();
|
||||
for (const Json& p : parts) a.push(p);
|
||||
return msg("user", a);
|
||||
}
|
||||
|
||||
Json ChatMessage::assistant(const std::string& t) { return msg("assistant", Json(t)); }
|
||||
|
||||
Json ChatMessage::assistant_tool_calls(const std::string& t, const std::vector<Json>& calls) {
|
||||
Json m = msg("assistant", t.empty() ? Json() : Json(t));
|
||||
Json a = Json::array();
|
||||
for (const Json& c : calls) a.push(c);
|
||||
m.set("tool_calls", a);
|
||||
return m;
|
||||
}
|
||||
|
||||
Json ChatMessage::tool_result(const std::string& id, const std::string& content) {
|
||||
Check::call_id(id);
|
||||
Json m = msg("tool", Json(content));
|
||||
m.set("tool_call_id", Json(id));
|
||||
return m;
|
||||
}
|
||||
|
||||
Json ChatMessage::text_part(const std::string& t) {
|
||||
Json p = part("text");
|
||||
p.set("text", Json(t));
|
||||
return p;
|
||||
}
|
||||
|
||||
Json ChatMessage::image_part(const std::string& url, const std::string& detail) {
|
||||
Check::non_empty("image url", url);
|
||||
if (!detail.empty()) Check::one_of("detail", detail, {"auto", "low", "high"});
|
||||
Json p = part("image_url");
|
||||
Json i = Json::object();
|
||||
i.set("url", Json(url));
|
||||
JsonX::set_if(i, "detail", detail);
|
||||
p.set("image_url", i);
|
||||
return p;
|
||||
}
|
||||
|
||||
Json ChatMessage::video_part(const std::string& url, double fps) {
|
||||
Check::non_empty("video url", url);
|
||||
Json p = part("video_url");
|
||||
Json v = Json::object();
|
||||
v.set("url", Json(url));
|
||||
if (fps > 0) v.set("fps", Json(fps));
|
||||
p.set("video_url", v);
|
||||
return p;
|
||||
}
|
||||
|
||||
Json ChatMessage::file_part(const std::string& filename, const std::string& data_url,
|
||||
const std::string& file_id) {
|
||||
if (data_url.empty() && file_id.empty()) Check::fail("file part needs file_data or file_id");
|
||||
Json p = part("file");
|
||||
Json f = Json::object();
|
||||
JsonX::set_if(f, "filename", filename);
|
||||
JsonX::set_if(f, "file_data", data_url);
|
||||
if (!file_id.empty()) {
|
||||
Check::segment("file_id", file_id);
|
||||
f.set("file_id", Json(file_id));
|
||||
}
|
||||
p.set("file", f);
|
||||
return p;
|
||||
}
|
||||
|
||||
Json ChatMessage::audio_part(const std::string& format, const std::string& b64) {
|
||||
Check::one_of("format", format, {"wav", "mp3"});
|
||||
Check::non_empty("audio data", b64);
|
||||
Json p = part("input_audio");
|
||||
Json a = Json::object();
|
||||
a.set("data", Json(b64));
|
||||
a.set("format", Json(format));
|
||||
p.set("input_audio", a);
|
||||
return p;
|
||||
}
|
||||
|
||||
Json ChatMessage::tool_call(const std::string& id, const std::string& name,
|
||||
const std::string& arguments) {
|
||||
Check::call_id(id);
|
||||
Check::function_name(name);
|
||||
Json c = Json::object();
|
||||
c.set("id", Json(id));
|
||||
c.set("type", Json("function"));
|
||||
Json f = Json::object();
|
||||
f.set("name", Json(name));
|
||||
f.set("arguments", Json(arguments.empty() ? "{}" : arguments));
|
||||
c.set("function", f);
|
||||
return c;
|
||||
}
|
||||
|
||||
Json ChatMessage::function_tool(const std::string& name, const std::string& description,
|
||||
const Json& parameters, bool strict) {
|
||||
Check::function_name(name);
|
||||
if (parameters.is_object()) SchemaCheck::check(parameters, strict);
|
||||
Json f = Json::object();
|
||||
f.set("name", Json(name));
|
||||
JsonX::set_if(f, "description", description);
|
||||
f.set("parameters", parameters.is_object() ? parameters : Json::object());
|
||||
if (strict) f.set("strict", Json(true));
|
||||
Json t = Json::object();
|
||||
t.set("type", Json("function"));
|
||||
t.set("function", f);
|
||||
return t;
|
||||
}
|
||||
|
||||
Json ChatCompletionRequest::format_json_object() {
|
||||
Json f = Json::object();
|
||||
f.set("type", Json("json_object"));
|
||||
return f;
|
||||
}
|
||||
|
||||
Json ChatCompletionRequest::format_json_schema(const std::string& name, const Json& schema,
|
||||
bool strict, const std::string& description) {
|
||||
Check::non_empty("name", name);
|
||||
SchemaCheck::check(schema, strict);
|
||||
Json js = Json::object();
|
||||
js.set("name", Json(name));
|
||||
js.set("schema", schema);
|
||||
if (strict) js.set("strict", Json(true));
|
||||
JsonX::set_if(js, "description", description);
|
||||
Json f = Json::object();
|
||||
f.set("type", Json("json_schema"));
|
||||
f.set("json_schema", js);
|
||||
return f;
|
||||
}
|
||||
|
||||
void ChatCompletionRequest::validate() const {
|
||||
Check::model_id(model);
|
||||
if (messages.empty() || messages.size() > MetaCaps::kMaxInputItems)
|
||||
Check::fail("messages needs 1.." + std::to_string(MetaCaps::kMaxInputItems) + " entries");
|
||||
for (const Json& m : messages) {
|
||||
Check::one_of("message role", JsonX::str(m, "role"),
|
||||
{"developer", "system", "user", "assistant", "tool"});
|
||||
}
|
||||
if (tools.size() > MetaCaps::kMaxTools) Check::fail("too many tools");
|
||||
for (const Json& t : tools) {
|
||||
if (JsonX::str(t, "type") != "function")
|
||||
Check::fail("chat completions accepts function tools only (custom tools are Responses-only)");
|
||||
if (const Json* f = JsonX::obj(t, "function")) Check::function_name(JsonX::str(*f, "name"));
|
||||
}
|
||||
if (max_completion_tokens && *max_completion_tokens < 1)
|
||||
Check::fail("max_completion_tokens must be positive");
|
||||
if (temperature) Check::temperature(*temperature);
|
||||
if (top_p) Check::top_p(*top_p);
|
||||
if (frequency_penalty) Check::penalty("frequency_penalty", *frequency_penalty);
|
||||
if (presence_penalty) Check::penalty("presence_penalty", *presence_penalty);
|
||||
Check::reasoning_effort(model, reasoning_effort);
|
||||
Check::safety_identifier(safety_identifier);
|
||||
Check::prompt_cache_retention(prompt_cache_retention);
|
||||
if (!service_tier.empty())
|
||||
Check::one_of("service_tier", service_tier, {"auto", "default", "flex", "scale", "priority"});
|
||||
if (metadata.size() > MetaCaps::kMaxMetadataPairs) Check::fail("too many metadata pairs");
|
||||
if (response_format.is_object()) {
|
||||
std::string type = JsonX::str(response_format, "type");
|
||||
Check::one_of("response_format.type", type, {"text", "json_object", "json_schema"});
|
||||
if (type == "json_schema") {
|
||||
const Json* js = JsonX::obj(response_format, "json_schema");
|
||||
const Json* s = js ? JsonX::obj(*js, "schema") : nullptr;
|
||||
if (!s) Check::fail("response_format json_schema needs json_schema.schema");
|
||||
SchemaCheck::check(*s, JsonX::flag(*js, "strict"));
|
||||
}
|
||||
}
|
||||
// Fields the docs reject on this endpoint must not arrive through `extra`.
|
||||
if (extra.is_object())
|
||||
for (const char* banned : {"n", "stop", "logit_bias", "prediction", "verbosity",
|
||||
"web_search_options", "modalities", "audio", "logprobs", "text",
|
||||
"max_output_tokens"})
|
||||
if (extra.has(banned)) Check::fail(std::string(banned) + " is rejected by chat completions");
|
||||
}
|
||||
|
||||
Json ChatCompletionRequest::to_json(bool stream) const {
|
||||
validate();
|
||||
Json b = Json::object();
|
||||
b.set("model", Json(model));
|
||||
Json m = Json::array();
|
||||
for (const Json& x : messages) m.push(x);
|
||||
b.set("messages", m);
|
||||
if (!tools.empty()) {
|
||||
Json t = Json::array();
|
||||
for (const Json& x : tools) t.push(x);
|
||||
b.set("tools", t);
|
||||
}
|
||||
if (response_format.is_object()) b.set("response_format", response_format);
|
||||
JsonX::set_if(b, "reasoning_effort", reasoning_effort);
|
||||
if (max_completion_tokens) b.set("max_completion_tokens", Json(*max_completion_tokens));
|
||||
if (temperature) b.set("temperature", Json(*temperature));
|
||||
if (top_p) b.set("top_p", Json(*top_p));
|
||||
if (frequency_penalty) b.set("frequency_penalty", Json(*frequency_penalty));
|
||||
if (presence_penalty) b.set("presence_penalty", Json(*presence_penalty));
|
||||
if (seed) b.set("seed", Json(*seed));
|
||||
if (parallel_tool_calls) b.set("parallel_tool_calls", Json(*parallel_tool_calls));
|
||||
JsonX::set_if(b, "safety_identifier", safety_identifier);
|
||||
JsonX::set_if(b, "prompt_cache_key", prompt_cache_key);
|
||||
JsonX::set_if(b, "prompt_cache_retention", prompt_cache_retention);
|
||||
JsonX::set_if(b, "service_tier", service_tier);
|
||||
if (!metadata.empty()) {
|
||||
Json md = Json::object();
|
||||
for (const auto& [k, v] : metadata) md.set(k, Json(v));
|
||||
b.set("metadata", md);
|
||||
}
|
||||
if (stream) {
|
||||
b.set("stream", Json(true));
|
||||
if (include_usage) {
|
||||
Json so = Json::object();
|
||||
so.set("include_usage", Json(true));
|
||||
b.set("stream_options", so);
|
||||
}
|
||||
}
|
||||
JsonX::merge(b, extra);
|
||||
return b;
|
||||
}
|
||||
|
||||
void ChatChunkAccumulator::feed(const Json& chunk) {
|
||||
id_ = JsonX::str(chunk, "id", id_);
|
||||
model_ = JsonX::str(chunk, "model", model_);
|
||||
if (const Json* u = JsonX::obj(chunk, "usage")) {
|
||||
usage_ = MetaUsage::from_chat(*u);
|
||||
has_usage_ = true;
|
||||
}
|
||||
const Json* choices = JsonX::arr(chunk, "choices");
|
||||
if (!choices || choices->as_array().empty()) return;
|
||||
const Json& c = choices->as_array()[0];
|
||||
std::string fr = JsonX::str(c, "finish_reason");
|
||||
if (!fr.empty()) finish_reason_ = fr;
|
||||
const Json* d = JsonX::obj(c, "delta");
|
||||
if (!d) return;
|
||||
text_ += JsonX::str(*d, "content");
|
||||
reasoning_ += JsonX::str(*d, "reasoning_content");
|
||||
if (const Json* tcs = JsonX::arr(*d, "tool_calls"))
|
||||
for (const Json& tc : tcs->as_array()) {
|
||||
long idx = JsonX::num(tc, "index", 0);
|
||||
ChatToolCallState* st = nullptr;
|
||||
for (ChatToolCallState& s : calls_)
|
||||
if (s.index == idx) st = &s;
|
||||
if (!st) {
|
||||
calls_.push_back({});
|
||||
st = &calls_.back();
|
||||
st->index = idx;
|
||||
}
|
||||
st->id = JsonX::str(tc, "id", st->id);
|
||||
if (const Json* f = JsonX::obj(tc, "function")) {
|
||||
st->name = JsonX::str(*f, "name", st->name);
|
||||
st->arguments += JsonX::str(*f, "arguments");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Json ChatCompletionsService::create(const ChatCompletionRequest& request) {
|
||||
Json body = request.to_json(false);
|
||||
return client_->post(path_for(Call::kChatCompletionsCreate), body);
|
||||
}
|
||||
|
||||
ChatChunkAccumulator ChatCompletionsService::stream(const ChatCompletionRequest& request,
|
||||
const ChunkSink& sink) {
|
||||
Json body = request.to_json(true);
|
||||
ChatChunkAccumulator acc;
|
||||
std::size_t seen = 0;
|
||||
client_->stream(path_for(Call::kChatCompletionsCreate), body, [&](const llm::SseEvent& e) {
|
||||
if (++seen > MetaCaps::kMaxStreamEvents) return false;
|
||||
acc.feed(e.data);
|
||||
return sink ? sink(e.data) : true;
|
||||
});
|
||||
return acc;
|
||||
}
|
||||
|
||||
} // namespace molo::meta
|
||||
Reference in New Issue
Block a user