marona 5.2.0

Agent SDK with coordinated B2A and D2A protocols, realtime device streams, structured responses, MCP and A2A
Documentation
//! B2A 1.0 content validation and model-input translation. No resource is fetched here.
use crate::{Error, Result};
macro_rules! bail {
    ($message:expr) => {
        return Err(Error::Validation($message.to_string()))
    };
}
use base64::{engine::general_purpose::STANDARD, Engine};
use serde_json::Value;

pub fn validate(message: &Value) -> Result<()> {
    if message["version"] != "1.0" || message["type"] != "message" {
        bail!("Expected a B2A 1.0 message");
    }
    if !message["source"]
        .as_str()
        .is_some_and(|v| !v.trim().is_empty() && v.len() <= 128)
    {
        bail!("A message source is required");
    }
    let items = message["payload"]["content"]
        .as_array()
        .ok_or_else(|| Error::Validation("content must be an array".into()))?;
    if items.is_empty() || items.len() > 64 {
        bail!("content must contain 1–64 blocks");
    }
    for item in items {
        let kind = item["type"]
            .as_str()
            .filter(|v| !v.is_empty() && v.len() <= 128)
            .ok_or_else(|| Error::Validation("A content type is required".into()))?;
        if let Some(confidence) = item.get("confidence") {
            if !confidence
                .as_f64()
                .is_some_and(|n| n.is_finite() && (0.0..=1.0).contains(&n))
            {
                bail!("confidence must be a finite number in [0,1]");
            }
        }
        if let Some(timing) = item.get("timing") {
            let start = timing["start_ms"].as_f64().filter(|v| *v >= 0.0);
            let end = timing["end_ms"].as_f64();
            if start.is_none() || end.is_none() || end < start {
                bail!("Invalid content timing");
            }
        }
        if item.get("data").is_some() == item.get("uri").is_some() {
            bail!("Provide exactly one of data or uri");
        }
        if let Some(uri) = item.get("uri") {
            let url = url::Url::parse(
                uri.as_str()
                    .ok_or_else(|| Error::Validation("uri must be a string".into()))?,
            )
            .map_err(|e| Error::Validation(e.to_string()))?;
            if !matches!(url.scheme(), "https" | "b2a")
                || !url.username().is_empty()
                || url.password().is_some()
                || url.host_str().is_none()
                || url.fragment().is_some()
            {
                bail!(
                    "Resource references require HTTPS or provider-owned b2a URIs without user credentials or fragments"
                );
            }
        }
        match kind {
            "text" => {
                if !item["data"].as_str().is_some_and(|v| !v.is_empty()) {
                    bail!("text.data must be nonempty text");
                }
            }
            "audio" | "image" | "video" => {
                let mime = item["mime_type"].as_str().unwrap_or("");
                if !mime.starts_with(&format!("{kind}/"))
                    || mime.len() > 128
                    || mime.chars().any(char::is_whitespace)
                {
                    bail!("Media requires a matching mime_type");
                }
                if item.get("data").is_some() {
                    if item["encoding"] != "base64" {
                        bail!("Inline media requires encoding: base64");
                    }
                    let bytes = STANDARD
                        .decode(item["data"].as_str().unwrap_or(""))
                        .map_err(|e| Error::Validation(e.to_string()))?;
                    if bytes.is_empty() {
                        bail!("Inline media must not be empty");
                    }
                }
            }
            "control" => {
                if !item["data"].is_object() {
                    bail!("control.data must be an object");
                }
            }
            "features" => {
                if item.get("uri").is_none()
                    && !item["data"].is_object()
                    && !item["data"].is_array()
                {
                    bail!("features requires structured data or a resource");
                }
            }
            _ => {
                if !kind.contains(':') {
                    bail!("Extension content types must be namespaced, for example vendor:pose");
                }
            }
        }
    }
    if let Some(stream) = message.get("stream") {
        if stream
            .get("mode")
            .is_some_and(|v| !matches!(v.as_str(), Some("snapshot" | "delta")))
        {
            bail!("stream.mode must be snapshot or delta");
        }
        if stream["mode"] == "delta" && (items.len() != 1 || items[0]["type"] != "text") {
            bail!("Delta streams require one text block");
        }
        if !stream["id"]
            .as_str()
            .is_some_and(|v| !v.is_empty() && v.len() <= 128)
            || stream["index"].as_u64().is_none()
            || !stream["final"].is_boolean()
        {
            bail!("stream requires id, nonnegative index and final");
        }
    }
    Ok(())
}