Files
moloapp/src/google/models/claude_models.cpp
T
retoorandClaude Sonnet 5.5 6b731643bf feat(clients): models: Gemini on Vertex, Model Garden, Claude, endpoint models, media, VertexModel
One call table verified against Discovery (29 calls), live-verified read-only
with an express key and a service account token, /agent/models example routes.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-24 04:40:00 +02:00

117 lines
4.4 KiB
C++

#include "google/models/claude_models.h"
#include "google/errors.h"
#include "google/models/json_read.h"
#include "google/models/caps.h"
namespace molo::google::models {
using clients::body::Json;
Json ClaudeRequest::to_json(bool stream) const {
Json body = Json::object();
body.set("anthropic_version", Json(ClaudeModels::kAnthropicVersion));
Json msgs = Json::array();
for (const ClaudeMessage& m : messages) {
Json one = Json::object();
one.set("role", Json(m.role));
one.set("content", Json(m.text));
msgs.push(one);
}
body.set("messages", msgs);
body.set("max_tokens", Json(max_tokens));
if (!system.empty()) body.set("system", Json(system));
if (temperature) body.set("temperature", Json(*temperature));
if (thinking_budget > 0) {
Json t = Json::object();
t.set("type", Json("enabled"));
t.set("budget_tokens", Json(thinking_budget));
body.set("thinking", t);
}
if (tools.is_array()) body.set("tools", tools);
if (stream) body.set("stream", Json(true));
return body;
}
ClaudeResponse ClaudeResponse::from_json(const Json& doc) {
ClaudeResponse r;
r.id = json_str(doc, "id");
r.model = json_str(doc, "model");
r.stop_reason = json_str(doc, "stop_reason");
if (const Json* c = doc.find("content"); c && c->is_array()) {
r.content = *c;
for (const Json& block : c->as_array())
if (json_str(block, "type") == "text")
r.text += json_str(block, "text");
}
if (const Json* u = doc.find("usage"); u && u->is_object()) {
r.input_tokens = static_cast<int>(json_num(*u, "input_tokens"));
r.output_tokens = static_cast<int>(json_num(*u, "output_tokens"));
}
return r;
}
ClaudeModels::ClaudeModels(std::shared_ptr<GoogleClient> client, VertexTarget target)
: VertexService(std::move(client), std::move(target), "aiplatform") {}
void ClaudeModels::validate(const ClaudeRequest& r) {
VertexTarget::require_segment(r.model, "model");
if (r.messages.empty()) throw GoogleError::invalid("no messages");
if (r.messages.size() > ModelsCaps::kMaxClaudeMessages)
throw GoogleError::invalid("more than " +
std::to_string(ModelsCaps::kMaxClaudeMessages) +
" messages");
if (r.messages.front().role != "user")
throw GoogleError::invalid("the first message must be from the user");
std::size_t chars = r.system.size();
for (const ClaudeMessage& m : r.messages) {
if (m.role != "user" && m.role != "assistant")
throw GoogleError::invalid("role must be user or assistant");
if (m.text.empty()) throw GoogleError::invalid("message text is empty");
chars += m.text.size();
}
if (chars > ModelsCaps::kMaxClaudeChars)
throw GoogleError::invalid("request text over " +
std::to_string(ModelsCaps::kMaxClaudeChars) +
" characters");
if (r.max_tokens < 1 || r.max_tokens > ModelsCaps::kMaxClaudeTokens)
throw GoogleError::invalid("max_tokens outside 1.." +
std::to_string(ModelsCaps::kMaxClaudeTokens));
if (r.temperature && (*r.temperature < 0.0 || *r.temperature > 1.0))
throw GoogleError::invalid("temperature outside 0..1");
if (r.thinking_budget != 0 &&
(r.thinking_budget < 1024 || r.thinking_budget >= r.max_tokens))
throw GoogleError::invalid("thinking_budget must be >= 1024 and < max_tokens");
}
PlannedCall ClaudeModels::plan_generate(const ClaudeRequest& request) const {
validate(request);
Json body = request.to_json(false);
return planner_.plan("partner.raw_predict", model_args("anthropic", request.model), &body);
}
PlannedCall ClaudeModels::plan_stream(const ClaudeRequest& request) const {
validate(request);
Json body = request.to_json(true);
return planner_.plan("partner.stream_raw_predict", model_args("anthropic", request.model), &body);
}
ClaudeResponse ClaudeModels::generate(const ClaudeRequest& request) const {
return ClaudeResponse::from_json(run(plan_generate(request)));
}
void ClaudeModels::stream(
const ClaudeRequest& request,
const std::function<bool(const Json&)>& sink) const {
run_stream(plan_stream(request), sink);
}
std::string ClaudeModels::text_delta(const Json& event) {
if (json_str(event, "type") != "content_block_delta") return "";
const Json* d = event.find("delta");
if (!d || !d->is_object() || json_str(*d, "type") != "text_delta") return "";
return json_str(*d, "text");
}
} // namespace molo::google::models