#include "google/runtime/agent_runtime.h" #include #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(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 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 AgentRuntime::list(const std::string& filter) const { Json items = list_items(Call::kList, context_.parent(), "reasoningEngines", filter); std::vector 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 AgentRuntime::test_iam_permissions( const std::string& id, const std::vector& 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(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 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 AgentRuntime::list_operations(const std::string& id) const { Json items = list_items(Call::kOperationList, name_of(id), "operations", ""); std::vector 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 AgentRuntime::list_revisions(const std::string& id) const { Json items = list_items(Call::kRevisionList, name_of(id), "reasoningEngineRuntimeRevisions", ""); std::vector 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