117 lines
4.4 KiB
C++
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
|