feat(clients): armor: Model Armor, SCC agent findings, GuardedModel, discovery-checked call table
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
@@ -0,0 +1,398 @@
|
||||
#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
|
||||
Reference in New Issue
Block a user