use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};
use crate::app::default_invocation_binding;
use everruns_core::channel::SessionBinding;
use everruns_provider::typed_id::{AgentEndpointId, AgentId, TriggerId};
#[cfg(feature = "openapi")]
use utoipa::ToSchema;
#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Default)]
#[cfg_attr(feature = "openapi", derive(ToSchema))]
#[serde(rename_all = "lowercase")]
pub enum AgentTriggerType {
#[default]
Schedule,
Webhook,
GitHub,
#[serde(rename = "mcp_event")]
McpEvent,
}
impl std::fmt::Display for AgentTriggerType {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
AgentTriggerType::Schedule => write!(f, "schedule"),
AgentTriggerType::Webhook => write!(f, "webhook"),
AgentTriggerType::GitHub => write!(f, "github"),
AgentTriggerType::McpEvent => write!(f, "mcp_event"),
}
}
}
impl From<&str> for AgentTriggerType {
fn from(value: &str) -> Self {
match value {
"webhook" => Self::Webhook,
"github" => Self::GitHub,
"mcp_event" => Self::McpEvent,
_ => Self::Schedule,
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "openapi", derive(ToSchema))]
pub struct ScheduleTriggerConfig {
pub cron_expression: String,
#[serde(default = "default_timezone")]
pub timezone: String,
#[serde(default = "default_invocation_binding")]
pub session_mode: SessionBinding,
pub message: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "openapi", derive(ToSchema))]
pub struct WebhookTriggerConfig {
pub token: String,
#[serde(default = "default_invocation_binding")]
pub session_mode: SessionBinding,
pub message: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub rate_limit_per_minute: Option<u32>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub event_id_template: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub subject_template: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub filter: Option<TriggerEventFilter>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "openapi", derive(ToSchema))]
pub struct GitHubTriggerConfig {
pub events: Vec<String>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub repositories: Vec<String>,
#[serde(default = "default_github_binding")]
pub session_mode: SessionBinding,
pub message: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub filter: Option<TriggerEventFilter>,
}
fn default_github_binding() -> SessionBinding {
SessionBinding::Thread
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[cfg_attr(feature = "openapi", derive(ToSchema))]
pub struct McpEventTriggerConfig {
pub server: String,
pub event: String,
#[serde(default = "empty_object")]
#[cfg_attr(feature = "openapi", schema(value_type = Object))]
pub arguments: serde_json::Value,
#[serde(default = "default_invocation_binding")]
pub session_mode: SessionBinding,
pub message: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub subject_template: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub filter: Option<TriggerEventFilter>,
}
fn empty_object() -> serde_json::Value {
serde_json::Value::Object(Default::default())
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq)]
#[cfg_attr(feature = "openapi", derive(ToSchema))]
pub struct TriggerEventFilter {
#[serde(default)]
pub conditions: Vec<TriggerFilterCondition>,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[cfg_attr(feature = "openapi", derive(ToSchema))]
pub struct TriggerFilterCondition {
pub path: String,
#[cfg_attr(feature = "openapi", schema(value_type = Vec<Object>))]
pub any_of: Vec<serde_json::Value>,
}
#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
#[cfg_attr(feature = "openapi", derive(ToSchema))]
#[serde(rename_all = "snake_case")]
pub enum TriggerDeliveryStatus {
Dispatched,
Filtered,
Duplicate,
Failed,
}
impl TriggerDeliveryStatus {
pub fn as_str(&self) -> &'static str {
match self {
Self::Dispatched => "dispatched",
Self::Filtered => "filtered",
Self::Duplicate => "duplicate",
Self::Failed => "failed",
}
}
}
impl std::str::FromStr for TriggerDeliveryStatus {
type Err = anyhow::Error;
fn from_str(value: &str) -> Result<Self, Self::Err> {
match value {
"dispatched" => Ok(Self::Dispatched),
"filtered" => Ok(Self::Filtered),
"duplicate" => Ok(Self::Duplicate),
"failed" => Ok(Self::Failed),
other => anyhow::bail!("unknown trigger delivery status {other}"),
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "openapi", derive(ToSchema))]
pub struct AgentTriggerDelivery {
#[cfg_attr(feature = "openapi", schema(value_type = String))]
pub id: uuid::Uuid,
pub source: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub event_id: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub event_type: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub subject: Option<String>,
pub status: TriggerDeliveryStatus,
#[serde(skip_serializing_if = "Option::is_none")]
pub reason: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
#[cfg_attr(feature = "openapi", schema(value_type = Option<String>))]
pub session_id: Option<everruns_provider::typed_id::SessionId>,
pub created_at: DateTime<Utc>,
}
fn default_timezone() -> String {
"UTC".to_string()
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "openapi", derive(ToSchema))]
pub struct AgentTrigger {
#[serde(rename = "id")]
#[cfg_attr(feature = "openapi", schema(value_type = String, example = "trg_01933b5a000070008000000000000001"))]
pub id: TriggerId,
#[cfg_attr(feature = "openapi", schema(value_type = String, example = "agent_01933b5a000070008000000000000001"))]
pub agent_id: AgentId,
pub trigger_type: AgentTriggerType,
#[serde(skip_serializing_if = "Option::is_none")]
#[cfg_attr(feature = "openapi", schema(value_type = Option<String>))]
pub ingress_id: Option<AgentEndpointId>,
pub config: serde_json::Value,
pub enabled: bool,
#[serde(default)]
pub agent_version_policy: crate::app::AgentVersionPolicy,
#[serde(default, skip_serializing_if = "Option::is_none")]
#[cfg_attr(feature = "openapi", schema(value_type = Option<String>, example = "agentver_01933b5a00007000800000000000001"))]
pub agent_version_id: Option<everruns_provider::typed_id::AgentVersionId>,
pub created_at: DateTime<Utc>,
pub updated_at: DateTime<Utc>,
#[serde(skip_serializing_if = "Option::is_none")]
pub archived_at: Option<DateTime<Utc>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub deleted_at: Option<DateTime<Utc>>,
}
impl AgentTrigger {
pub fn schedule_config(&self) -> anyhow::Result<ScheduleTriggerConfig> {
if self.trigger_type != AgentTriggerType::Schedule {
anyhow::bail!("agent trigger {} is not a schedule trigger", self.id);
}
Ok(serde_json::from_value(self.config.clone())?)
}
pub fn github_config(&self) -> anyhow::Result<GitHubTriggerConfig> {
if self.trigger_type != AgentTriggerType::GitHub {
anyhow::bail!("agent trigger {} is not a GitHub trigger", self.id);
}
Ok(serde_json::from_value(self.config.clone())?)
}
pub fn mcp_event_config(&self) -> anyhow::Result<McpEventTriggerConfig> {
if self.trigger_type != AgentTriggerType::McpEvent {
anyhow::bail!("agent trigger {} is not an MCP event trigger", self.id);
}
Ok(serde_json::from_value(self.config.clone())?)
}
pub fn webhook_config(&self) -> anyhow::Result<WebhookTriggerConfig> {
if self.trigger_type != AgentTriggerType::Webhook {
anyhow::bail!("agent trigger {} is not a webhook trigger", self.id);
}
Ok(serde_json::from_value(self.config.clone())?)
}
}