Files
moloapp/src/google/runtime/agent_runtime.cpp
T
retoorandClaude Sonnet 5.5 8e807945a2 feat(clients): models+runtime: close gaps (all Discovery methods wrapped, live re-verification)
models: EndpointAdmin and PublisherAdmin wrap every remaining method of the
owned resources (84 call table rows, 132 Discovery methods covered, v1beta1
twins, IAM, operations, responses, export, config, enableModel); planner
rejects undeclared body keys; VertexModel::TurnBuilder replays model turns
with every thoughtSignature; Lyria WAV mime from bytes; veo-3.1 default.
runtime: v1beta1 feedbackEntries, A2A gateway (40 rpcs), a2aTasks, task store
records, scoped operations, beta twin flag (103 rows, 214 methods covered);
checker verifies twins, a2aEndpoint patterns and coverage.
example: admin routes for both parts. SPECs: live results moved from
Unverified to Verified live (Veo, Lyria, thought signatures, v1beta1 routes).

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

320 lines
13 KiB
C++

#include "google/runtime/agent_runtime.h"
#include <cctype>
#include "clients/url.h"
#include "google/errors.h"
#include "google/runtime/caps.h"
namespace molo::google::runtime {
using clients::body::Json;
namespace {
void check_method(const std::string& m) {
if (m.empty() || m.size() > RuntimeCaps::kMaxMethodChars)
throw GoogleError::invalid("bad classMethod");
for (char c : m)
if (!((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') ||
c == '_'))
throw GoogleError::invalid("bad classMethod");
}
void check_gcs(const std::string& uri, const char* what) {
if (uri.rfind("gs://", 0) != 0 || uri.size() <= 5 ||
uri.size() > RuntimeCaps::kMaxUriChars)
throw GoogleError::invalid(std::string(what) + " must be a gs:// URI");
for (char c : uri)
if (static_cast<unsigned char>(c) <= 0x20) throw GoogleError::invalid("bad gs:// URI");
}
void check_size(const Json& j, const char* what) {
if (j.dump().size() > RuntimeCaps::kMaxInputBytes)
throw GoogleError::invalid(std::string(what) + " too large");
}
std::string enc(const std::string& s) { return clients::Url::encode_component(s); }
} // namespace
Revision Revision::from_json(const Json& doc) {
Revision r;
r.raw = doc;
if (!doc.is_object()) return r;
auto s = [&](const char* k) {
const Json* v = doc.find(k);
return v && v->is_string() ? v->as_string() : std::string();
};
r.name = s("name");
r.state = s("state");
r.create_time = s("createTime");
if (const Json* sp = doc.find("spec")) r.spec = EngineSpec::from_json(*sp);
return r;
}
AgentRuntime::AgentRuntime(std::shared_ptr<GoogleClient> client, CloudContext context,
Sleeper sleeper, bool beta)
: Service(std::move(client), beta ? endpoints::aiplatform_beta(context.location)
: endpoints::aiplatform(context.location)),
context_(std::move(context)),
sleeper_(std::move(sleeper)),
beta_(beta) {}
OperationCalls AgentRuntime::operations() const {
return OperationCalls(client_, context_.location, beta_);
}
std::string AgentRuntime::name_of(const std::string& id) const {
return context_.child("reasoningEngines", id);
}
std::string AgentRuntime::revision_of(const std::string& id, const std::string& revision) const {
if (!valid_segment(revision)) throw GoogleError::invalid("bad revision id");
return name_of(id) + "/runtimeRevisions/" + revision;
}
std::string AgentRuntime::checked_operation(const std::string& name) {
if (name.rfind("projects/", 0) != 0 || name.size() > 512 ||
name.find("..") != std::string::npos || name.find('?') != std::string::npos)
throw GoogleError::invalid("bad operation name");
return name;
}
Json AgentRuntime::send(Call call, const std::string& target, const std::string& query,
const Json* body) const {
std::string path = render(call, target) + query;
return client_->request(method_of(call), endpoint_of(call, context_.location, beta_), path, body);
}
std::size_t AgentRuntime::stream_call(Call call, const std::string& target, const Json& body,
const GoogleClient::EventSink& sink) const {
std::size_t n = 0;
client_->stream_json(endpoint_of(call, context_.location, beta_), render(call, target), body,
[&](const Json& event) {
++n;
bool more = sink(event);
return more && n < RuntimeCaps::kMaxStreamEvents;
});
return n;
}
Json AgentRuntime::list_items(Call call, const std::string& parent, const std::string& key,
const std::string& filter) const {
if (filter.size() > RuntimeCaps::kMaxFilterChars) throw GoogleError::invalid("filter too long");
std::string path = render(call, parent) + "?pageSize=50";
if (!filter.empty()) path += "&filter=" + enc(filter);
return list_all(*client_, endpoint_of(call, context_.location, beta_), path, key,
RuntimeCaps::kMaxListPages);
}
Operation AgentRuntime::finish(Operation op) const {
if (!op.done) return wait_operation(*client_, endpoint_, checked_operation(op.name), sleeper_);
if (op.failed()) throw GoogleError(502, "OPERATION_FAILED", op.error_message, endpoint_.name);
return op;
}
Engine AgentRuntime::engine_from(const Operation& op) const {
if (op.response.is_object()) {
Engine e = Engine::from_json(op.response);
if (!e.name.empty()) return get(e.id());
}
throw GoogleError(502, "BAD_RESPONSE", "operation finished without an engine name",
endpoint_.name);
}
// --- engines ---------------------------------------------------------------
Operation AgentRuntime::create_start(const EngineDraft& draft) const {
Json body = draft.to_json();
return Operation::from_json(send(Call::kCreate, context_.parent(), "", &body));
}
Engine AgentRuntime::create(const EngineDraft& draft) const {
return engine_from(finish(create_start(draft)));
}
Engine AgentRuntime::get(const std::string& id) const {
return Engine::from_json(send(Call::kGet, name_of(id)));
}
std::vector<Engine> AgentRuntime::list(const std::string& filter) const {
Json items = list_items(Call::kList, context_.parent(), "reasoningEngines", filter);
std::vector<Engine> out;
for (const Json& j : items.as_array()) out.push_back(Engine::from_json(j));
return out;
}
Operation AgentRuntime::update_start(const std::string& id, const EngineUpdate& update) const {
std::string name = name_of(id);
Json body = update.to_json();
body.set("name", Json(name));
return Operation::from_json(
send(Call::kPatch, name, "?updateMask=" + enc(update.update_mask()), &body));
}
Engine AgentRuntime::update(const std::string& id, const EngineUpdate& update_in) const {
finish(update_start(id, update_in));
return get(id);
}
Operation AgentRuntime::destroy_start(const std::string& id, bool force) const {
return Operation::from_json(
send(Call::kDelete, name_of(id), force ? "?force=true" : "?force=false"));
}
Operation AgentRuntime::destroy(const std::string& id, bool force) const {
return finish(destroy_start(id, force));
}
// --- queries ---------------------------------------------------------------
Json AgentRuntime::query_body(const Json& input, const std::string& class_method) {
check_method(class_method);
if (!input.is_object()) throw GoogleError::invalid("input must be a JSON object");
check_size(input, "input");
Json body = Json::object();
body.set("input", input);
body.set("classMethod", Json(class_method));
return body;
}
Json AgentRuntime::query(const std::string& id, const Json& input,
const std::string& class_method) const {
Json body = query_body(input, class_method);
return send(Call::kQuery, name_of(id), "", &body);
}
std::size_t AgentRuntime::stream_query(const std::string& id, const Json& input,
const GoogleClient::EventSink& sink,
const std::string& class_method) const {
return stream_call(Call::kStreamQuery, name_of(id), query_body(input, class_method), sink);
}
Operation AgentRuntime::async_query(const std::string& id, const std::string& input_gcs_uri,
const std::string& output_gcs_uri) const {
check_gcs(input_gcs_uri, "inputGcsUri");
check_gcs(output_gcs_uri, "outputGcsUri");
Json body = Json::object();
body.set("inputGcsUri", Json(input_gcs_uri));
body.set("outputGcsUri", Json(output_gcs_uri));
return Operation::from_json(send(Call::kAsyncQuery, name_of(id), "", &body));
}
void AgentRuntime::cancel_async_query(const std::string& id,
const std::string& operation_name) const {
Json body = Json::object();
body.set("operationName", Json(checked_operation(operation_name)));
send(Call::kCancelAsyncQuery, name_of(id), "", &body);
}
Json AgentRuntime::execute_code(const std::string& id, const Json& inputs) const {
if (!inputs.is_array() || inputs.as_array().empty())
throw GoogleError::invalid("inputs must be a non-empty array of chunks");
check_size(inputs, "inputs");
Json body = Json::object();
body.set("inputs", inputs);
return send(Call::kExecuteCode, name_of(id), "", &body);
}
// --- IAM -------------------------------------------------------------------
Json AgentRuntime::get_iam_policy(const std::string& id, int policy_version) const {
if (policy_version < 0 || policy_version > 3) throw GoogleError::invalid("policy version 0..3");
std::string q = policy_version ? "?options.requestedPolicyVersion=" + std::to_string(policy_version)
: "";
return send(Call::kGetIamPolicy, name_of(id), q);
}
Json AgentRuntime::set_iam_policy(const std::string& id, const Json& policy) const {
if (!policy.is_object()) throw GoogleError::invalid("policy must be an object");
check_size(policy, "policy");
Json body = Json::object();
body.set("policy", policy);
return send(Call::kSetIamPolicy, name_of(id), "", &body);
}
std::vector<std::string> AgentRuntime::test_iam_permissions(
const std::string& id, const std::vector<std::string>& permissions) const {
if (permissions.empty() || permissions.size() > 64)
throw GoogleError::invalid("1 to 64 permissions");
std::string q;
for (const auto& p : permissions) {
if (p.empty() || p.size() > 128) throw GoogleError::invalid("bad permission");
for (char c : p)
if (!std::isalnum(static_cast<unsigned char>(c)) && c != '.' && c != '_')
throw GoogleError::invalid("bad permission");
q += (q.empty() ? "?permissions=" : "&permissions=") + enc(p);
}
Json reply = send(Call::kTestIamPermissions, name_of(id), q);
std::vector<std::string> out;
if (const Json* a = reply.find("permissions"); a && a->is_array())
for (const Json& p : a->as_array())
if (p.is_string()) out.push_back(p.as_string());
return out;
}
// --- operations ------------------------------------------------------------
Operation AgentRuntime::operation(const std::string& operation_name) const {
return Operation::from_json(send(Call::kOperationGet, checked_operation(operation_name)));
}
Operation AgentRuntime::wait(const std::string& operation_name) const {
return wait_operation(*client_, endpoint_, checked_operation(operation_name), sleeper_);
}
std::vector<Operation> AgentRuntime::list_operations(const std::string& id) const {
Json items = list_items(Call::kOperationList, name_of(id), "operations", "");
std::vector<Operation> out;
for (const Json& j : items.as_array()) out.push_back(Operation::from_json(j));
return out;
}
void AgentRuntime::cancel_operation(const std::string& operation_name) const {
send(Call::kOperationCancel, checked_operation(operation_name));
}
void AgentRuntime::delete_operation(const std::string& operation_name) const {
send(Call::kOperationDelete, checked_operation(operation_name));
}
// --- revisions -------------------------------------------------------------
Revision AgentRuntime::get_revision(const std::string& id, const std::string& revision) const {
return Revision::from_json(send(Call::kRevisionGet, revision_of(id, revision)));
}
std::vector<Revision> AgentRuntime::list_revisions(const std::string& id) const {
Json items = list_items(Call::kRevisionList, name_of(id), "reasoningEngineRuntimeRevisions", "");
std::vector<Revision> out;
for (const Json& j : items.as_array()) out.push_back(Revision::from_json(j));
return out;
}
Operation AgentRuntime::destroy_revision_start(const std::string& id,
const std::string& revision) const {
return Operation::from_json(send(Call::kRevisionDelete, revision_of(id, revision)));
}
Operation AgentRuntime::destroy_revision(const std::string& id, const std::string& revision) const {
return finish(destroy_revision_start(id, revision));
}
Json AgentRuntime::query_revision(const std::string& id, const std::string& revision,
const Json& input, const std::string& class_method) const {
Json body = query_body(input, class_method);
return send(beta_ ? Call::kRevisionQuery : Call::kRevisionQueryV1, revision_of(id, revision), "", &body);
}
std::size_t AgentRuntime::stream_query_revision(const std::string& id, const std::string& revision,
const Json& input,
const GoogleClient::EventSink& sink,
const std::string& class_method) const {
return stream_call(beta_ ? Call::kRevisionStreamQuery : Call::kRevisionStreamQueryV1,
revision_of(id, revision),
query_body(input, class_method), sink);
}
} // namespace molo::google::runtime