Files
moloapp/src/openai/admin/webhook_events.cpp
T

206 lines
7.8 KiB
C++
Raw Normal View History

#include "openai/admin/webhook_events.h"
#include <algorithm>
#include <iterator>
#include "llm/error.h"
#include "openai/admin/caps.h"
#include "openai/admin/validate.h"
namespace molo::openai::admin {
using clients::body::Json;
// EVENT-SPECS (payload description per event; `webhooks` map of the OpenAPI document)
static const WebhookEventSpec kEvents[] = {
{"agent.environment.expired", "agent_environment_expired", "id", "id"},
{"agent.environment.failed", "agent_environment_failed", "id", "id"},
{"agent.environment.ready", "agent_environment_ready", "id", "id"},
{"agent.environment.suspended", "agent_environment_suspended", "id", "id"},
{"agent.session.action_required", "agent_session_action_required", "id,required_action", "id,required_action"},
{"agent.session.created", "agent_session_created", "id,environment_id,environment_type,connect", "id,environment_type"},
{"agent.session.failed", "agent_session_failed", "id,environment_id,environment_type", "id,environment_type"},
{"agent.session.idle", "agent_session_idle", "id,environment_id,environment_type", "id,environment_type"},
{"agent.session.in_progress", "agent_session_in_progress", "id,environment_id,environment_type", "id,environment_type"},
{"batch.cancelled", "batch_cancelled", "id", "id"},
{"batch.completed", "batch_completed", "id", "id"},
{"batch.expired", "batch_expired", "id", "id"},
{"batch.failed", "batch_failed", "id", "id"},
{"eval.run.canceled", "eval_run_canceled", "id", "id"},
{"eval.run.failed", "eval_run_failed", "id", "id"},
{"eval.run.succeeded", "eval_run_succeeded", "id", "id"},
{"fine_tuning.job.cancelled", "fine_tuning_job_cancelled", "id", "id"},
{"fine_tuning.job.failed", "fine_tuning_job_failed", "id", "id"},
{"fine_tuning.job.succeeded", "fine_tuning_job_succeeded", "id", "id"},
{"live.call.incoming", "live_call_incoming", "session_id,sip_media_security,sip_headers", "session_id,sip_headers"},
{"live.transport.incoming", "live_transport_incoming", "type,session_id,sip_media_security,sip_headers", "type,session_id,sip_headers"},
{"realtime.call.incoming", "realtime_call_incoming", "call_id,sip_media_security,sip_headers", "call_id,sip_headers"},
{"response.cancelled", "response_cancelled", "id", "id"},
{"response.completed", "response_completed", "id", "id"},
{"response.failed", "response_failed", "id", "id"},
{"response.incomplete", "response_incomplete", "id", "id"},
{"safety.alert.created", "safety_alert_created", "id", "id"},
{"safety.deactivation_issued", "safety_deactivation_issued", "id", "id"},
{"safety.org_alert.created", "safety_org_alert_created", "id", "id"},
{"safety.warning_issued", "safety_warning_issued", "id", "id"},
};
// WEBHOOK-EVENTS-BEGIN (types of kEvents; checked by tools/check_spec.py)
static const char* const kSent[] = {
"agent.environment.expired",
"agent.environment.failed",
"agent.environment.ready",
"agent.environment.suspended",
"agent.session.action_required",
"agent.session.created",
"agent.session.failed",
"agent.session.idle",
"agent.session.in_progress",
"batch.cancelled",
"batch.completed",
"batch.expired",
"batch.failed",
"eval.run.canceled",
"eval.run.failed",
"eval.run.succeeded",
"fine_tuning.job.cancelled",
"fine_tuning.job.failed",
"fine_tuning.job.succeeded",
"live.call.incoming",
"live.transport.incoming",
"realtime.call.incoming",
"response.cancelled",
"response.completed",
"response.failed",
"response.incomplete",
"safety.alert.created",
"safety.deactivation_issued",
"safety.org_alert.created",
"safety.warning_issued",
};
// WEBHOOK-EVENTS-END
// SUBSCRIBABLE-BEGIN (ProjectEventTypeEnum; checked by tools/check_spec.py)
static const char* const kSubscribable[] = {
"batch.completed",
"batch.failed",
"batch.expired",
"batch.cancelled",
"response.completed",
"response.failed",
"response.cancelled",
"response.incomplete",
"eval.run.succeeded",
"eval.run.failed",
"eval.run.canceled",
"fine_tuning.job.succeeded",
"fine_tuning.job.failed",
"fine_tuning.job.cancelled",
"realtime.call.incoming",
"video.completed",
"video.failed",
"agent.environment.ready",
"agent.environment.failed",
"agent.environment.suspended",
"agent.environment.expired",
"agent.session.created",
"agent.session.action_required",
"agent.session.in_progress",
"agent.session.idle",
"agent.session.failed",
"safety.alert.created",
};
// SUBSCRIBABLE-END
std::size_t WebhookEvents::count() { return sizeof(kEvents) / sizeof(kEvents[0]); }
const WebhookEventSpec& WebhookEvents::at(std::size_t index) {
if (index >= count()) Validate::fail("webhook event index out of range");
return kEvents[index];
}
const WebhookEventSpec* WebhookEvents::find(const std::string& type) {
for (const WebhookEventSpec& e : kEvents)
if (type == e.type) return &e;
return nullptr;
}
const std::vector<std::string>& WebhookEvents::sent() {
static const std::vector<std::string> v(std::begin(kSent), std::end(kSent));
return v;
}
const std::vector<std::string>& WebhookEvents::subscribable() {
static const std::vector<std::string> v(std::begin(kSubscribable), std::end(kSubscribable));
return v;
}
bool WebhookEvents::is_subscribable(const std::string& type) {
const auto& v = subscribable();
return std::find(v.begin(), v.end(), type) != v.end();
}
std::string WebhookEvent::family() const { return type.substr(0, type.find('.')); }
std::string WebhookEvent::resource_id() const {
const Json* id_field = data.is_object() ? data.find("id") : nullptr;
return id_field && id_field->is_string() ? id_field->as_string() : "";
}
Json WebhookEvent::to_json() const {
Json o = Json::object();
o.set("id", Json(id));
o.set("type", Json(type));
o.set("created_at", Json(static_cast<long>(created_at)));
o.set("family", Json(family()));
o.set("resource_id", Json(resource_id()));
o.set("known", Json(known));
Json missing = Json::array();
for (const std::string& m : missing_data_fields) missing.push(Json(m));
o.set("missing_data_fields", missing);
o.set("data", data);
return o;
}
WebhookEvent WebhookEnvelope::parse(const std::string& body) {
if (body.size() > AdminCaps::kMaxWebhookBodyBytes) Validate::fail("webhook body over the cap");
Json doc;
try {
doc = Json::parse(body);
} catch (const std::exception&) {
Validate::fail("webhook body is not JSON");
}
if (!doc.is_object()) Validate::fail("webhook body is not an object");
WebhookEvent ev;
const Json* id_f = doc.find("id");
const Json* type_f = doc.find("type");
const Json* created = doc.find("created_at");
const Json* data = doc.find("data");
const Json* object = doc.find("object");
if (!id_f || !id_f->is_string() || id_f->as_string().empty()) Validate::fail("event has no id");
if (!type_f || !type_f->is_string() || type_f->as_string().empty()) Validate::fail("event has no type");
if (!created || !created->is_number()) Validate::fail("event has no created_at");
if (!data || !data->is_object()) Validate::fail("event has no data object");
if (object && (!object->is_string() || object->as_string() != "event"))
Validate::fail("event object is not \"event\"");
ev.id = id_f->as_string();
ev.type = type_f->as_string();
ev.created_at = static_cast<std::int64_t>(created->as_int());
ev.data = *data;
if (const WebhookEventSpec* spec = WebhookEvents::find(ev.type)) {
ev.known = true;
std::string list = spec->required_data;
std::size_t from = 0;
while (from < list.size()) {
std::size_t comma = list.find(',', from);
std::string field = list.substr(from, comma == std::string::npos ? std::string::npos : comma - from);
if (!field.empty() && !data->find(field)) ev.missing_data_fields.push_back(field);
if (comma == std::string::npos) break;
from = comma + 1;
}
}
return ev;
}
} // namespace molo::openai::admin