use alloc::collections::BTreeMap;
use alloc::string::String;
use alloc::vec::Vec;
use serde::{Deserialize, Serialize};
use serde_json::{Map, Value};
use crate::Extra;
use crate::enums::{HookEvent, HookOnFailure, Shell};
use crate::walk::{Unknown, join, walk};
pub type Hooks = BTreeMap<HookEvent, Vec<HookMatcher>>;
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[non_exhaustive]
pub struct HookMatcher {
#[serde(skip_serializing_if = "Option::is_none")]
pub matcher: Option<String>,
#[serde(default)]
pub hooks: Vec<Hook>,
#[serde(flatten)]
pub extra: Extra,
}
impl HookMatcher {
pub fn all(hooks: impl IntoIterator<Item = Hook>) -> Self {
Self {
hooks: hooks.into_iter().collect(),
..Self::default()
}
}
pub fn matching(matcher: impl Into<String>, hooks: impl IntoIterator<Item = Hook>) -> Self {
Self {
matcher: Some(matcher.into()),
..Self::all(hooks)
}
}
}
walk!(HookMatcher { hooks: "hooks" });
#[derive(Debug, Clone, PartialEq)]
#[non_exhaustive]
pub enum Hook {
Command(CommandHook),
Prompt(PromptHook),
Agent(AgentHook),
Http(HttpHook),
McpTool(McpToolHook),
Other(Map<String, Value>),
}
impl Hook {
pub fn command(command: impl Into<String>) -> Self {
Self::Command(CommandHook::new(command))
}
pub fn kind(&self) -> Option<&str> {
match self {
Self::Command(_) => Some("command"),
Self::Prompt(_) => Some("prompt"),
Self::Agent(_) => Some("agent"),
Self::Http(_) => Some("http"),
Self::McpTool(_) => Some("mcp_tool"),
Self::Other(m) => m.get("type").and_then(Value::as_str),
}
}
}
impl Serialize for Hook {
fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
let inner = match self {
Self::Command(h) => serde_json::to_value(h),
Self::Prompt(h) => serde_json::to_value(h),
Self::Agent(h) => serde_json::to_value(h),
Self::Http(h) => serde_json::to_value(h),
Self::McpTool(h) => serde_json::to_value(h),
Self::Other(m) => return m.serialize(s),
};
let Value::Object(mut obj) = inner.map_err(serde::ser::Error::custom)? else {
return Err(serde::ser::Error::custom("a hook serializes as an object"));
};
if let Some(kind) = self.kind() {
obj.insert("type".into(), kind.into());
}
obj.serialize(s)
}
}
impl<'de> Deserialize<'de> for Hook {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
fn parse<T: serde::de::DeserializeOwned, E: serde::de::Error>(
mut obj: Map<String, Value>,
) -> Result<T, E> {
obj.remove("type");
serde_json::from_value(Value::Object(obj)).map_err(E::custom)
}
let obj = Map::<String, Value>::deserialize(d)?;
Ok(match obj.get("type").and_then(Value::as_str) {
Some("command") => Self::Command(parse(obj)?),
Some("prompt") => Self::Prompt(parse(obj)?),
Some("agent") => Self::Agent(parse(obj)?),
Some("http") => Self::Http(parse(obj)?),
Some("mcp_tool") => Self::McpTool(parse(obj)?),
_ => Self::Other(obj),
})
}
}
impl Unknown for Hook {
fn unknown(&self, path: &str, out: &mut Vec<String>) {
match self {
Self::Command(h) => h.unknown(path, out),
Self::Prompt(h) => h.unknown(path, out),
Self::Agent(h) => h.unknown(path, out),
Self::Http(h) => h.unknown(path, out),
Self::McpTool(h) => h.unknown(path, out),
Self::Other(_) => out.push(join(path, "type")),
}
}
}
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[non_exhaustive]
pub struct CommandHook {
#[serde(skip_serializing_if = "Option::is_none")]
pub command: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub args: Option<Vec<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub timeout: Option<f64>,
#[serde(rename = "async", skip_serializing_if = "Option::is_none")]
pub run_async: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub async_rewake: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub shell: Option<Shell>,
#[serde(rename = "if", skip_serializing_if = "Option::is_none")]
pub condition: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub status_message: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub on_failure: Option<HookOnFailure>,
#[serde(flatten)]
pub extra: Extra,
}
impl CommandHook {
pub fn new(command: impl Into<String>) -> Self {
Self {
command: Some(command.into()),
..Self::default()
}
}
#[must_use]
pub fn with_timeout(mut self, seconds: f64) -> Self {
self.timeout = Some(seconds);
self
}
}
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[non_exhaustive]
pub struct PromptHook {
#[serde(skip_serializing_if = "Option::is_none")]
pub prompt: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub model: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub timeout: Option<f64>,
#[serde(rename = "if", skip_serializing_if = "Option::is_none")]
pub condition: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub status_message: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub continue_on_block: Option<bool>,
#[serde(flatten)]
pub extra: Extra,
}
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[non_exhaustive]
pub struct AgentHook {
#[serde(skip_serializing_if = "Option::is_none")]
pub prompt: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub model: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub timeout: Option<f64>,
#[serde(rename = "if", skip_serializing_if = "Option::is_none")]
pub condition: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub status_message: Option<String>,
#[serde(flatten)]
pub extra: Extra,
}
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[non_exhaustive]
pub struct HttpHook {
#[serde(skip_serializing_if = "Option::is_none")]
pub url: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub headers: Option<BTreeMap<String, String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub allowed_env_vars: Option<Vec<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub timeout: Option<f64>,
#[serde(rename = "if", skip_serializing_if = "Option::is_none")]
pub condition: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub status_message: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub on_failure: Option<HookOnFailure>,
#[serde(flatten)]
pub extra: Extra,
}
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[non_exhaustive]
pub struct McpToolHook {
#[serde(skip_serializing_if = "Option::is_none")]
pub server: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub tool: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub input: Option<Map<String, Value>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub timeout: Option<f64>,
#[serde(rename = "if", skip_serializing_if = "Option::is_none")]
pub condition: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub status_message: Option<String>,
#[serde(flatten)]
pub extra: Extra,
}
walk!(CommandHook {});
walk!(PromptHook {});
walk!(AgentHook {});
walk!(HttpHook {});
walk!(McpToolHook {});