feat(a2a-redaction): introduce scaffold with redactor trait, identifiers, and Tier-3 sentinel (#388)

Signed-off-by: Yordis Prieto <yordis.prieto@gmail.com>

Author: yordis

rsworkspace/Cargo.lock

@@ -19,6 +19,7 @@ a2a-bridge = { path = "crates/a2a-bridge" }
 a2a-identity-types = { path = "crates/a2a-identity-types" }
 a2a-nats = { path = "crates/a2a-nats" }
 a2a-pack = { path = "crates/a2a-pack" }
+a2a-redaction = { path = "crates/a2a-redaction" }
 acp-nats = { path = "crates/acp-nats" }
 trogon-telemetry = { path = "crates/trogon-telemetry" }
 mcp-nats = { path = "crates/mcp-nats" }

rsworkspace/Cargo.toml

@@ -0,0 +1,20 @@
+[package]
+name = "a2a-redaction"
+version = "0.1.0"
+edition = "2024"
+license = "Apache-2.0"
+description = "A2A redaction primitives, redactor trait, and Tier-3 refusal sentinel"
+publish = false
+
+[lib]
+name = "a2a_redaction"
+path = "src/lib.rs"
+
+[lints]
+workspace = true
+
+[dependencies]
+a2a = { workspace = true }
+serde = { workspace = true, features = ["derive"] }
+serde_json = { workspace = true }
+thiserror = { workspace = true }

rsworkspace/crates/a2a-redaction/Cargo.toml

@@ -0,0 +1,123 @@
+use std::fmt;
+use std::str::FromStr;
+
+use serde::{Deserialize, Serialize};
+
+/// A2A wire methods. The serde wire form is the canonical slash-delimited
+/// string (e.g. `message/send`), matching `as_str` / `Display` / `FromStr`
+/// so the same value round-trips across JSON and string parsing without
+/// silently switching representation.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
+pub enum A2aMethod {
+    #[serde(rename = "message/send")]
+    MessageSend,
+    #[serde(rename = "message/stream")]
+    MessageStream,
+    #[serde(rename = "tasks/get")]
+    TasksGet,
+    #[serde(rename = "tasks/list")]
+    TasksList,
+    #[serde(rename = "tasks/cancel")]
+    TasksCancel,
+    #[serde(rename = "tasks/resubscribe")]
+    TasksResubscribe,
+    #[serde(rename = "tasks/pushNotificationConfig/set")]
+    PushNotificationSet,
+    #[serde(rename = "tasks/pushNotificationConfig/get")]
+    PushNotificationGet,
+    #[serde(rename = "tasks/pushNotificationConfig/list")]
+    PushNotificationList,
+    #[serde(rename = "tasks/pushNotificationConfig/delete")]
+    PushNotificationDelete,
+    #[serde(rename = "agent/getAuthenticatedExtendedCard")]
+    AgentCard,
+}
+
+impl A2aMethod {
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            Self::MessageSend => "message/send",
+            Self::MessageStream => "message/stream",
+            Self::TasksGet => "tasks/get",
+            Self::TasksList => "tasks/list",
+            Self::TasksCancel => "tasks/cancel",
+            Self::TasksResubscribe => "tasks/resubscribe",
+            Self::PushNotificationSet => "tasks/pushNotificationConfig/set",
+            Self::PushNotificationGet => "tasks/pushNotificationConfig/get",
+            Self::PushNotificationList => "tasks/pushNotificationConfig/list",
+            Self::PushNotificationDelete => "tasks/pushNotificationConfig/delete",
+            Self::AgentCard => "agent/getAuthenticatedExtendedCard",
+        }
+    }
+
+    pub fn all() -> &'static [Self] {
+        &[
+            Self::MessageSend,
+            Self::MessageStream,
+            Self::TasksGet,
+            Self::TasksList,
+            Self::TasksCancel,
+            Self::TasksResubscribe,
+            Self::PushNotificationSet,
+            Self::PushNotificationGet,
+            Self::PushNotificationList,
+            Self::PushNotificationDelete,
+            Self::AgentCard,
+        ]
+    }
+}
+
+impl fmt::Display for A2aMethod {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(self.as_str())
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)]
+#[error("unknown A2A method: {value}")]
+pub struct ParseA2aMethodError {
+    pub value: String,
+}
+
+impl FromStr for A2aMethod {
+    type Err = ParseA2aMethodError;
+
+    fn from_str(value: &str) -> Result<Self, Self::Err> {
+        Self::all()
+            .iter()
+            .copied()
+            .find(|method| method.as_str() == value)
+            .ok_or_else(|| ParseA2aMethodError {
+                value: value.to_owned(),
+            })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn roundtrip_display_parse() {
+        for method in A2aMethod::all() {
+            let parsed = method.as_str().parse::<A2aMethod>().unwrap();
+            assert_eq!(parsed, *method);
+        }
+    }
+
+    #[test]
+    fn serde_uses_canonical_wire_strings() {
+        let method = A2aMethod::MessageSend;
+        let wire = serde_json::to_string(&method).expect("serialize");
+        assert_eq!(wire, "\"message/send\"");
+        let back: A2aMethod = serde_json::from_str(&wire).expect("deserialize");
+        assert_eq!(back, method);
+    }
+
+    #[test]
+    fn parse_error_includes_unknown_value() {
+        let err = "not/real".parse::<A2aMethod>().unwrap_err();
+        assert_eq!(err.value, "not/real");
+        assert!(err.to_string().contains("not/real"));
+    }
+}

rsworkspace/crates/a2a-redaction/src/a2a_method.rs

@@ -0,0 +1,36 @@
+#[derive(Debug, thiserror::Error)]
+pub enum RedactionError {
+    #[error("wasm engine initialization failed: {0}")]
+    WasmEngine(String),
+    #[error("wasm module compile failed: {0}")]
+    WasmModule(String),
+    #[error("wasm module instantiation failed: {0}")]
+    WasmInstance(String),
+    #[error("wasm redaction abi mismatch: {0}")]
+    WasmAbi(String),
+    #[error("wasm redact_part call failed: {0}")]
+    WasmCall(String),
+    #[error("wasm linear memory access failed: {0}")]
+    WasmMemory(String),
+    /// JSON encode/decode of a `Part` payload failed. Preserves the typed
+    /// `serde_json::Error` as `source()` so error chains survive past this
+    /// boundary instead of being flattened to a String.
+    #[error("json serialization for redaction failed: {0}")]
+    Json(#[from] serde_json::Error),
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn wasm_engine_variant_carries_underlying_message() {
+        let inner = "module init failed";
+        let wrapped = RedactionError::WasmEngine(inner.to_string());
+        assert!(
+            wrapped.to_string().contains("wasm engine initialization failed"),
+            "{wrapped}"
+        );
+        assert!(wrapped.to_string().contains(inner));
+    }
+}

rsworkspace/crates/a2a-redaction/src/error.rs

@@ -0,0 +1,22 @@
+//! A2A redaction primitives: typed identifiers, redactor trait, no-op
+//! implementation, and Tier-3 refusal sentinel.
+//!
+//! Subsequent slices add the skill manifest, signed-bundle verification, and
+//! the wasm redactor host on top of these foundations.
+#![cfg_attr(test, allow(clippy::expect_used, clippy::panic, clippy::unwrap_used))]
+
+pub mod a2a_method;
+pub mod error;
+pub mod noop;
+pub mod redactor;
+pub mod skill_id;
+pub mod tier3_sentinel;
+pub mod wasm_bundle_path;
+
+pub use a2a_method::{A2aMethod, ParseA2aMethodError};
+pub use error::RedactionError;
+pub use noop::NoopRedactor;
+pub use redactor::Redactor;
+pub use skill_id::{SkillId, SkillIdError};
+pub use tier3_sentinel::{TIER3_REFUSE_SENTINEL, output_is_tier3_refusal, tier3_refusal_reason_tag};
+pub use wasm_bundle_path::WasmBundlePath;

rsworkspace/crates/a2a-redaction/src/lib.rs

@@ -0,0 +1,54 @@
+use crate::redactor::Redactor;
+
+pub struct NoopRedactor;
+
+impl Redactor for NoopRedactor {}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use a2a::types::{Artifact, Message, Role};
+
+    use crate::skill_id::SkillId;
+
+    #[test]
+    fn message_identity() {
+        let r = NoopRedactor;
+        let msg = Message {
+            message_id: "mid".into(),
+            context_id: None,
+            task_id: None,
+            role: Role::User,
+            parts: vec![a2a::types::Part {
+                content: a2a::types::PartContent::Text("hello".into()),
+                filename: None,
+                media_type: None,
+                metadata: None,
+            }],
+            metadata: None,
+            extensions: None,
+            reference_task_ids: None,
+        };
+        let out = r
+            .redact_message(msg.clone(), &SkillId::new("skill").expect("valid"))
+            .unwrap();
+        assert_eq!(serde_json::to_value(out).unwrap(), serde_json::to_value(msg).unwrap());
+    }
+
+    #[test]
+    fn artifact_identity() {
+        let r = NoopRedactor;
+        let art = Artifact {
+            artifact_id: "a".into(),
+            name: None,
+            description: None,
+            parts: vec![],
+            metadata: None,
+            extensions: None,
+        };
+        let out = r
+            .redact_artifact(art.clone(), &SkillId::new("skill").expect("valid"))
+            .unwrap();
+        assert_eq!(serde_json::to_value(out).unwrap(), serde_json::to_value(art).unwrap());
+    }
+}

rsworkspace/crates/a2a-redaction/src/noop.rs

@@ -0,0 +1,103 @@
+use a2a::types::{Artifact, Message, Part};
+
+use crate::error::RedactionError;
+use crate::skill_id::SkillId;
+
+pub trait Redactor {
+    fn redact_message(&self, message: Message, _skill: &SkillId) -> Result<Message, RedactionError> {
+        Ok(message)
+    }
+
+    fn redact_artifact(&self, artifact: Artifact, _skill: &SkillId) -> Result<Artifact, RedactionError> {
+        Ok(artifact)
+    }
+}
+
+#[allow(dead_code)]
+pub(crate) fn redact_message_parts_with(
+    mut message: Message,
+    mut transform_part_json: impl FnMut(&[u8]) -> Result<Vec<u8>, RedactionError>,
+) -> Result<Message, RedactionError> {
+    let mut next_parts = Vec::with_capacity(message.parts.len());
+    for part in core::mem::take(&mut message.parts) {
+        let wire = serde_json::to_vec(&part)?;
+        let out = transform_part_json(&wire)?;
+        let parsed: Part = serde_json::from_slice(&out)?;
+        next_parts.push(parsed);
+    }
+    message.parts = next_parts;
+    Ok(message)
+}
+
+#[allow(dead_code)]
+pub(crate) fn redact_artifact_parts_with(
+    mut artifact: Artifact,
+    mut transform_part_json: impl FnMut(&[u8]) -> Result<Vec<u8>, RedactionError>,
+) -> Result<Artifact, RedactionError> {
+    let mut next_parts = Vec::with_capacity(artifact.parts.len());
+    for part in core::mem::take(&mut artifact.parts) {
+        let wire = serde_json::to_vec(&part)?;
+        let out = transform_part_json(&wire)?;
+        let parsed: Part = serde_json::from_slice(&out)?;
+        next_parts.push(parsed);
+    }
+    artifact.parts = next_parts;
+    Ok(artifact)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use a2a::types::{PartContent, Role};
+
+    struct DefaultRedactorByTrait;
+
+    impl Redactor for DefaultRedactorByTrait {}
+
+    #[test]
+    fn default_redact_message_identity() {
+        let r = DefaultRedactorByTrait;
+        let msg = Message {
+            message_id: "m".into(),
+            context_id: None,
+            task_id: None,
+            role: Role::User,
+            parts: vec![],
+            metadata: None,
+            extensions: None,
+            reference_task_ids: None,
+        };
+        assert_eq!(
+            serde_json::to_value(
+                r.redact_message(msg.clone(), &SkillId::new("s").expect("valid"))
+                    .unwrap()
+            )
+            .unwrap(),
+            serde_json::to_value(&msg).unwrap()
+        );
+    }
+
+    #[test]
+    fn part_loop_identity_preserves_shapes() {
+        let msg_in = Message {
+            message_id: "m".into(),
+            context_id: None,
+            task_id: None,
+            role: Role::Agent,
+            parts: vec![a2a::types::Part {
+                content: PartContent::Text("secret".into()),
+                filename: None,
+                media_type: None,
+                metadata: None,
+            }],
+            metadata: None,
+            extensions: None,
+            reference_task_ids: None,
+        };
+        let msg_out = redact_message_parts_with(msg_in.clone(), |b| Ok(b.to_vec())).expect("identity json transform");
+        assert_eq!(
+            serde_json::to_value(&msg_out).unwrap(),
+            serde_json::to_value(&msg_in).unwrap()
+        );
+    }
+}