use std::collections::HashSet;
use crate::error::A2aError;
pub const SKILL_INVOCATION_PROFILE_V1: &str =
"https://turul.dev/a2a/extensions/skill-invocation/v1";
pub const SKILL_ID_METADATA_KEY: &str = "a2a.skillId";
pub const SKILL_PARAMS_METADATA_KEY: &str = "a2a.skillParams";
pub fn check_skill_invocation_request(
negotiated: &HashSet<String>,
request: &serde_json::Value,
) -> Result<(), A2aError> {
if !negotiated.contains(SKILL_INVOCATION_PROFILE_V1) {
return Ok(());
}
let Some(message) = request.get("message") else {
return Ok(());
};
match message
.get("metadata")
.and_then(|m| m.get(SKILL_ID_METADATA_KEY))
{
Some(serde_json::Value::String(_)) => Ok(()),
Some(_) => Err(A2aError::InvalidRequest {
message: format!(
"Message.metadata[\"{SKILL_ID_METADATA_KEY}\"] must be a string when \
extension '{SKILL_INVOCATION_PROFILE_V1}' is activated"
),
}),
None => Err(A2aError::InvalidRequest {
message: format!(
"Message.metadata[\"{SKILL_ID_METADATA_KEY}\"] is required when \
extension '{SKILL_INVOCATION_PROFILE_V1}' is activated"
),
}),
}
}
pub fn check_skill_invocation_body(
negotiated: &HashSet<String>,
body: &str,
) -> Result<(), A2aError> {
if !negotiated.contains(SKILL_INVOCATION_PROFILE_V1) {
return Ok(());
}
match serde_json::from_str::<serde_json::Value>(body) {
Ok(request) => check_skill_invocation_request(negotiated, &request),
Err(_) => Ok(()),
}
}
pub fn parse_a2a_extensions(header_value: Option<&str>) -> HashSet<String> {
let mut out = HashSet::new();
let Some(raw) = header_value else {
return out;
};
for segment in raw.split(',') {
let trimmed = segment.trim();
if trimmed.is_empty() {
continue;
}
out.insert(trimmed.to_string());
}
out
}
pub fn validate_activation(
activated: &HashSet<String>,
advertised: &[turul_a2a_proto::AgentExtension],
) -> Result<HashSet<String>, A2aError> {
for ext in advertised {
if ext.required && !activated.contains(&ext.uri) {
return Err(A2aError::ExtensionSupportRequired {
extension: ext.uri.clone(),
});
}
}
let advertised_uris: HashSet<&str> = advertised.iter().map(|e| e.uri.as_str()).collect();
let intersection: HashSet<String> = activated
.iter()
.filter(|uri| advertised_uris.contains(uri.as_str()))
.cloned()
.collect();
Ok(intersection)
}
pub fn response_header_value(activated: &HashSet<String>) -> Option<String> {
if activated.is_empty() {
return None;
}
let mut sorted: Vec<&str> = activated.iter().map(String::as_str).collect();
sorted.sort_unstable();
Some(sorted.join(", "))
}
pub use turul_a2a_types::wire::protocol::EXTENSIONS_PARAM as A2A_EXTENSIONS_HEADER;
pub fn activated_from_headers(headers: &axum::http::HeaderMap) -> HashSet<String> {
let raw = headers
.get(A2A_EXTENSIONS_HEADER)
.and_then(|v| v.to_str().ok());
parse_a2a_extensions(raw)
}
#[cfg(test)]
mod tests {
use super::*;
fn ext(uri: &str, required: bool) -> turul_a2a_proto::AgentExtension {
turul_a2a_proto::AgentExtension {
uri: uri.into(),
description: String::new(),
required,
params: None,
}
}
#[test]
fn parser_empty_and_whitespace() {
assert!(parse_a2a_extensions(None).is_empty());
assert!(parse_a2a_extensions(Some("")).is_empty());
assert!(parse_a2a_extensions(Some(" , ,")).is_empty());
}
#[test]
fn parser_trims_and_splits() {
let set = parse_a2a_extensions(Some(" a , b , a "));
assert_eq!(set.len(), 2);
assert!(set.contains("a"));
assert!(set.contains("b"));
}
#[test]
fn validate_required_missing_errors() {
let advertised = vec![ext("uri-1", true)];
let activated = HashSet::new();
assert!(matches!(
validate_activation(&activated, &advertised),
Err(A2aError::ExtensionSupportRequired { extension }) if extension == "uri-1"
));
}
#[test]
fn validate_required_present_ok() {
let advertised = vec![ext("uri-1", true)];
let mut activated = HashSet::new();
activated.insert("uri-1".to_string());
let result = validate_activation(&activated, &advertised).unwrap();
assert_eq!(result.len(), 1);
}
#[test]
fn validate_unknown_uri_ignored() {
let advertised = vec![ext("uri-1", false)];
let mut activated = HashSet::new();
activated.insert("uri-2".to_string());
let result = validate_activation(&activated, &advertised).unwrap();
assert!(result.is_empty());
}
#[test]
fn header_value_stable_sort() {
let mut set = HashSet::new();
set.insert("b".to_string());
set.insert("a".to_string());
assert_eq!(response_header_value(&set).unwrap(), "a, b");
}
}