Files
moloapp/src/google/armor/template.cpp
T

399 lines
16 KiB
C++

#include "google/armor/template.h"
#include "google/armor/caps.h"
#include "google/errors.h"
namespace molo::google::armor {
using clients::body::Json;
namespace {
const Json* member(const Json& doc, const char* key) {
return doc.is_object() ? doc.find(key) : nullptr;
}
std::string text_of(const Json& doc, const char* key) {
const Json* v = member(doc, key);
return v && v->is_string() ? v->as_string() : std::string();
}
bool flag_of(const Json& doc, const char* key) {
const Json* v = member(doc, key);
return v && v->is_bool() && v->as_bool();
}
int int_of(const Json& doc, const char* key) {
const Json* v = member(doc, key);
return v && v->is_number() ? static_cast<int>(v->as_int()) : 0;
}
bool valid_rai_type(const std::string& t) {
return t == "SEXUALLY_EXPLICIT" || t == "HATE_SPEECH" || t == "HARASSMENT" ||
t == "DANGEROUS";
}
bool upper_name(const std::string& v) {
if (v.empty() || v.size() > 64) return false;
for (char c : v)
if (!((c >= 'A' && c <= 'Z') || c == '_')) return false;
return true;
}
Json enabled_json(bool on) {
Json o = Json::object();
o.set("filterEnforcement", on ? "ENABLED" : "DISABLED");
return o;
}
bool enabled(const Json* settings) {
return settings && text_of(*settings, "filterEnforcement") == "ENABLED";
}
Json enforcement_json(const FloorEnforcement& e) {
Json p = Json::object();
p.set("enableCloudLogging", e.cloud_logging);
p.set(e.inspect_only ? "inspectOnly" : "inspectAndBlock", true);
return p;
}
FloorEnforcement enforcement_from(const Json& p) {
FloorEnforcement e;
e.present = true;
e.cloud_logging = flag_of(p, "enableCloudLogging");
e.inspect_only = flag_of(p, "inspectOnly");
return e;
}
Json rule_sets_json(const std::vector<FilterRuleSet>& sets) {
Json arr = Json::array();
for (const auto& rs : sets) {
Json set = Json::object();
Json types = Json::array();
for (const auto& t : rs.filter_types) types.push(t);
set.set("filterTypes", types);
Json rules = Json::array();
for (const auto& r : rs.rules) {
Json ex = Json::object();
if (!r.matching_scope.empty()) ex.set("matchingScope", r.matching_scope);
if (!r.regex.empty()) {
Json re = Json::object();
re.set("pattern", r.regex);
ex.set("regex", re);
} else {
Json words = Json::array();
for (const auto& w : r.words) words.push(w);
Json list = Json::object();
list.set("words", words);
Json dict = Json::object();
dict.set("wordList", list);
ex.set("dictionary", dict);
}
Json rule = Json::object();
rule.set("exclusionRule", ex);
rules.push(rule);
}
set.set("rules", rules);
arr.push(set);
}
Json settings = Json::object();
settings.set("ruleSets", arr);
return settings;
}
std::vector<FilterRuleSet> rule_sets_from(const Json& settings) {
std::vector<FilterRuleSet> out;
const Json* sets = member(settings, "ruleSets");
if (!sets || !sets->is_array()) return out;
for (const Json& set : sets->as_array()) {
if (out.size() >= ArmorCaps::kMaxRuleSets) break;
FilterRuleSet rs;
if (const Json* t = member(set, "filterTypes"); t && t->is_array())
for (const Json& x : t->as_array())
if (x.is_string()) rs.filter_types.push_back(x.as_string());
if (const Json* rules = member(set, "rules"); rules && rules->is_array())
for (const Json& rule : rules->as_array()) {
const Json* ex = member(rule, "exclusionRule");
if (!ex || rs.rules.size() >= ArmorCaps::kMaxRulesPerSet) continue;
ExclusionRule er;
er.matching_scope = text_of(*ex, "matchingScope");
if (const Json* re = member(*ex, "regex")) er.regex = text_of(*re, "pattern");
if (const Json* dict = member(*ex, "dictionary"))
if (const Json* wl = member(*dict, "wordList"))
if (const Json* w = member(*wl, "words"); w && w->is_array())
for (const Json& x : w->as_array())
if (x.is_string() && er.words.size() < ArmorCaps::kMaxRuleWords)
er.words.push_back(x.as_string());
rs.rules.push_back(std::move(er));
}
out.push_back(std::move(rs));
}
return out;
}
} // namespace
void FilterConfig::validate() const {
if (rai.size() > ArmorCaps::kMaxRaiFilters)
throw GoogleError::invalid("too many rai filters");
for (const auto& f : rai)
if (!valid_rai_type(f.type))
throw GoogleError::invalid("rai filter type must be SEXUALLY_EXPLICIT, "
"HATE_SPEECH, HARASSMENT or DANGEROUS");
if (rule_sets.size() > ArmorCaps::kMaxRuleSets)
throw GoogleError::invalid("too many rule sets");
for (const auto& rs : rule_sets) {
if (rs.rules.size() > ArmorCaps::kMaxRulesPerSet)
throw GoogleError::invalid("too many rules in a rule set");
for (const auto& t : rs.filter_types)
if (!upper_name(t)) throw GoogleError::invalid("bad rule set filter type");
for (const auto& r : rs.rules) {
if (r.words.size() > ArmorCaps::kMaxRuleWords ||
r.regex.size() > ArmorCaps::kMaxRegexChars)
throw GoogleError::invalid("exclusion rule too large");
if (!r.matching_scope.empty() && !upper_name(r.matching_scope))
throw GoogleError::invalid("bad matching scope");
if (r.regex.empty() && r.words.empty())
throw GoogleError::invalid("exclusion rule needs words or a regex");
}
}
if (sdp == SdpMode::kAdvanced && sdp_inspect_template.empty())
throw GoogleError::invalid("advanced sdp needs an inspect template");
if (sdp_inspect_template.size() > 512 || sdp_deidentify_template.size() > 512)
throw GoogleError::invalid("sdp template name too long");
}
Json FilterConfig::to_json() const {
Json o = Json::object();
if (!rai.empty()) {
Json filters = Json::array();
for (const auto& f : rai) {
Json item = Json::object();
item.set("filterType", f.type);
if (f.confidence != Confidence::kUnspecified)
item.set("confidenceLevel", confidence_name(f.confidence));
filters.push(item);
}
Json settings = Json::object();
settings.set("raiFilters", filters);
o.set("raiSettings", settings);
}
if (!rule_sets.empty()) o.set("filterRuleSettings", rule_sets_json(rule_sets));
if (sdp == SdpMode::kBasic) {
Json settings = Json::object();
settings.set("basicConfig", enabled_json(true));
o.set("sdpSettings", settings);
} else if (sdp == SdpMode::kAdvanced) {
Json adv = Json::object();
adv.set("inspectTemplate", sdp_inspect_template);
if (!sdp_deidentify_template.empty())
adv.set("deidentifyTemplate", sdp_deidentify_template);
Json settings = Json::object();
settings.set("advancedConfig", adv);
o.set("sdpSettings", settings);
}
if (prompt_injection) {
Json pi = enabled_json(true);
if (prompt_injection_confidence != Confidence::kUnspecified)
pi.set("confidenceLevel", confidence_name(prompt_injection_confidence));
o.set("piAndJailbreakFilterSettings", pi);
}
if (malicious_uri) o.set("maliciousUriFilterSettings", enabled_json(true));
return o;
}
FilterConfig FilterConfig::from_json(const Json& doc) {
FilterConfig c;
if (const Json* r = member(doc, "raiSettings"))
if (const Json* list = member(*r, "raiFilters"); list && list->is_array())
for (const Json& f : list->as_array()) {
if (c.rai.size() >= ArmorCaps::kMaxRaiFilters) break;
c.rai.push_back({text_of(f, "filterType"),
confidence_from(text_of(f, "confidenceLevel"))});
}
if (const Json* r = member(doc, "filterRuleSettings")) c.rule_sets = rule_sets_from(*r);
if (const Json* s = member(doc, "sdpSettings")) {
if (const Json* adv = member(*s, "advancedConfig")) {
c.sdp = SdpMode::kAdvanced;
c.sdp_inspect_template = text_of(*adv, "inspectTemplate");
c.sdp_deidentify_template = text_of(*adv, "deidentifyTemplate");
} else if (const Json* basic = member(*s, "basicConfig")) {
if (enabled(basic)) c.sdp = SdpMode::kBasic;
}
}
if (const Json* pi = member(doc, "piAndJailbreakFilterSettings")) {
c.prompt_injection = enabled(pi);
c.prompt_injection_confidence = confidence_from(text_of(*pi, "confidenceLevel"));
}
c.malicious_uri = enabled(member(doc, "maliciousUriFilterSettings"));
return c;
}
void TemplateMetadata::validate() const {
if (!enforcement.empty() && enforcement != "INSPECT_ONLY" &&
enforcement != "INSPECT_AND_BLOCK")
throw GoogleError::invalid("enforcement must be INSPECT_ONLY or INSPECT_AND_BLOCK");
if (custom_prompt_error_message.size() > 1024 ||
custom_response_error_message.size() > 1024)
throw GoogleError::invalid("custom error message too long");
if (custom_prompt_error_code < 0 || custom_response_error_code < 0)
throw GoogleError::invalid("custom error code must not be negative");
if (!filter_version_alias.empty() && !upper_name(filter_version_alias))
throw GoogleError::invalid("bad filter version alias");
if (!filter_version.empty() && !filter_version_alias.empty())
throw GoogleError::invalid("filter version and alias are mutually exclusive");
if (filter_version.size() > 32) throw GoogleError::invalid("filter version too long");
if (modalities.size() > 2) throw GoogleError::invalid("too many modalities");
for (const auto& m : modalities)
if (m != "MODALITY_TEXT" && m != "MODALITY_IMAGE")
throw GoogleError::invalid("modality must be MODALITY_TEXT or MODALITY_IMAGE");
}
Json TemplateMetadata::to_json() const {
Json o = Json::object();
if (!enforcement.empty()) o.set("enforcementType", enforcement);
if (ignore_partial_failures) o.set("ignorePartialInvocationFailures", true);
if (log_template_operations) o.set("logTemplateOperations", true);
if (log_sanitize_operations) o.set("logSanitizeOperations", true);
if (multi_language_detection) {
Json m = Json::object();
m.set("enableMultiLanguageDetection", true);
o.set("multiLanguageDetection", m);
}
if (custom_prompt_error_code) o.set("customPromptSafetyErrorCode", custom_prompt_error_code);
if (!custom_prompt_error_message.empty())
o.set("customPromptSafetyErrorMessage", custom_prompt_error_message);
if (custom_response_error_code)
o.set("customLlmResponseSafetyErrorCode", custom_response_error_code);
if (!custom_response_error_message.empty())
o.set("customLlmResponseSafetyErrorMessage", custom_response_error_message);
if (!filter_version.empty() || !filter_version_alias.empty()) {
Json sel = Json::object();
if (!filter_version.empty()) sel.set("version", filter_version);
if (!filter_version_alias.empty()) sel.set("alias", filter_version_alias);
o.set("filterVersionSelector", sel);
}
if (!modalities.empty()) {
Json m = Json::array();
for (const auto& x : modalities) m.push(x);
o.set("modalities", m);
}
if (data_residency_set) o.set("dataResidencyCompliant", data_residency_compliant);
return o;
}
TemplateMetadata TemplateMetadata::from_json(const Json& doc) {
TemplateMetadata m;
m.enforcement = text_of(doc, "enforcementType");
if (m.enforcement == "ENFORCEMENT_TYPE_UNSPECIFIED") m.enforcement.clear();
m.ignore_partial_failures = flag_of(doc, "ignorePartialInvocationFailures");
m.log_template_operations = flag_of(doc, "logTemplateOperations");
m.log_sanitize_operations = flag_of(doc, "logSanitizeOperations");
if (const Json* ml = member(doc, "multiLanguageDetection"))
m.multi_language_detection = flag_of(*ml, "enableMultiLanguageDetection");
m.custom_prompt_error_code = int_of(doc, "customPromptSafetyErrorCode");
m.custom_prompt_error_message = text_of(doc, "customPromptSafetyErrorMessage");
m.custom_response_error_code = int_of(doc, "customLlmResponseSafetyErrorCode");
m.custom_response_error_message = text_of(doc, "customLlmResponseSafetyErrorMessage");
if (const Json* sel = member(doc, "filterVersionSelector")) {
m.filter_version = text_of(*sel, "version");
m.filter_version_alias = text_of(*sel, "alias");
}
if (const Json* mods = member(doc, "modalities"); mods && mods->is_array())
for (const Json& x : mods->as_array())
if (x.is_string() && m.modalities.size() < 2) m.modalities.push_back(x.as_string());
if (const Json* r = member(doc, "dataResidencyCompliant"); r && r->is_bool()) {
m.data_residency_set = true;
m.data_residency_compliant = r->as_bool();
}
return m;
}
void Template::validate() const {
filter.validate();
metadata.validate();
if (labels.size() > ArmorCaps::kMaxLabels)
throw GoogleError::invalid("too many labels");
for (const auto& [k, v] : labels)
if (k.empty() || k.size() > ArmorCaps::kMaxLabelChars ||
v.size() > ArmorCaps::kMaxLabelChars)
throw GoogleError::invalid("label key or value too long");
}
Json Template::to_json() const {
Json o = Json::object();
o.set("filterConfig", filter.to_json());
Json meta = metadata.to_json();
if (!meta.as_object().empty()) o.set("templateMetadata", meta);
if (!labels.empty()) {
Json l = Json::object();
for (const auto& [k, v] : labels) l.set(k, v);
o.set("labels", l);
}
return o;
}
Template Template::from_json(const Json& doc) {
Template t;
t.name = text_of(doc, "name");
t.create_time = text_of(doc, "createTime");
t.update_time = text_of(doc, "updateTime");
if (const Json* f = member(doc, "filterConfig")) t.filter = FilterConfig::from_json(*f);
if (const Json* m = member(doc, "templateMetadata"))
t.metadata = TemplateMetadata::from_json(*m);
if (const Json* l = member(doc, "labels"); l && l->is_object())
for (const auto& [k, v] : l->as_object())
if (v.is_string() && t.labels.size() < ArmorCaps::kMaxLabels)
t.labels[k] = v.as_string();
return t;
}
void FloorSetting::validate() const {
filter.validate();
for (const auto& s : integrated_services)
if (s != "AI_PLATFORM" && s != "GOOGLE_MCP_SERVER")
throw GoogleError::invalid(
"integrated service must be AI_PLATFORM or GOOGLE_MCP_SERVER");
if (integrated_services.size() > 2) throw GoogleError::invalid("too many integrated services");
}
Json FloorSetting::to_json() const {
Json o = Json::object();
o.set("filterConfig", filter.to_json());
o.set("enableFloorSettingEnforcement", enforcement_enabled);
if (!integrated_services.empty()) {
Json s = Json::array();
for (const auto& x : integrated_services) s.push(x);
o.set("integratedServices", s);
}
if (ai_platform.present) o.set("aiPlatformFloorSetting", enforcement_json(ai_platform));
if (mcp_server.present) o.set("googleMcpServerFloorSetting", enforcement_json(mcp_server));
if (multi_language_detection) {
Json ml = Json::object();
ml.set("enableMultiLanguageDetection", true);
Json meta = Json::object();
meta.set("multiLanguageDetection", ml);
o.set("floorSettingMetadata", meta);
}
return o;
}
FloorSetting FloorSetting::from_json(const Json& doc) {
FloorSetting f;
f.name = text_of(doc, "name");
f.update_time = text_of(doc, "updateTime");
f.ai_platform = FloorEnforcement{};
if (const Json* c = member(doc, "filterConfig")) f.filter = FilterConfig::from_json(*c);
f.enforcement_enabled = flag_of(doc, "enableFloorSettingEnforcement");
if (const Json* s = member(doc, "integratedServices"); s && s->is_array())
for (const Json& x : s->as_array())
if (x.is_string() && f.integrated_services.size() < 2)
f.integrated_services.push_back(x.as_string());
if (const Json* p = member(doc, "aiPlatformFloorSetting")) f.ai_platform = enforcement_from(*p);
if (const Json* p = member(doc, "googleMcpServerFloorSetting"))
f.mcp_server = enforcement_from(*p);
if (const Json* m = member(doc, "floorSettingMetadata"))
if (const Json* ml = member(*m, "multiLanguageDetection"))
f.multi_language_detection = flag_of(*ml, "enableMultiLanguageDetection");
return f;
}
} // namespace molo::google::armor