lc-a2a 0.22.0

A2A (Agent-to-Agent) protocol support for langchainrust — client, server, and protocol types.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

//! Skill-based chain routing (P2-4).
//!
//! `A2AServer` can be handed a [`SkillRouter`] so that incoming `tasks/send`
//! requests carrying a `skillId` are dispatched to a different underlying
//! chain than the default one, based on the skills advertised on the agent
//! card. [`SkillMapRouter`] is the concrete static mapping shipped here.

use std::collections::HashMap;
use std::sync::Arc;

use lc_chains::base::BaseChain;

/// Resolves a chain for a requested skill id (P2-4).
///
/// Return `None` to fall back to the server's default chain. Implementations
/// must be cheap and infallible — they run on every `tasks/send`.
pub trait SkillRouter: Send + Sync {
    /// The chain that should handle `skill_id`, if any.
    fn chain_for(&self, skill_id: &str) -> Option<Arc<dyn BaseChain>>;
}

/// Static `skill_id -> chain` mapping.
///
/// The keys should match the skill ids advertised on the agent card so that
/// clients can discover which skills are routable.
#[derive(Default)]
pub struct SkillMapRouter {
    skills: HashMap<String, Arc<dyn BaseChain>>,
}

impl SkillMapRouter {
    /// Create an empty router (all requests fall through to the default chain).
    pub fn new() -> Self {
        Self::default()
    }

    /// Register a chain for a skill id.
    pub fn with_skill(mut self, skill_id: impl Into<String>, chain: Arc<dyn BaseChain>) -> Self {
        self.skills.insert(skill_id.into(), chain);
        self
    }
}

impl SkillRouter for SkillMapRouter {
    fn chain_for(&self, skill_id: &str) -> Option<Arc<dyn BaseChain>> {
        self.skills.get(skill_id).cloned()
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use lc_chains::base::{ChainError, ChainResult};
    use serde_json::Value;

    /// A trivial chain that names itself, so routing can be observed.
    struct NamedChain(String);

    #[async_trait::async_trait]
    impl BaseChain for NamedChain {
        fn input_keys(&self) -> Vec<&str> {
            vec!["input"]
        }

        fn output_keys(&self) -> Vec<&str> {
            vec!["output"]
        }

        async fn invoke(&self, _inputs: HashMap<String, Value>) -> Result<ChainResult, ChainError> {
            let mut out = HashMap::new();
            out.insert("output".to_string(), Value::String(self.0.clone()));
            Ok(out)
        }

        fn name(&self) -> &str {
            &self.0
        }
    }

    fn arc_named(name: &str) -> Arc<dyn BaseChain> {
        Arc::new(NamedChain(name.to_string()))
    }

    #[test]
    fn empty_router_falls_through() {
        let router = SkillMapRouter::new();
        assert!(router.chain_for("anything").is_none());
    }

    #[test]
    fn routes_by_skill_id() {
        let router = SkillMapRouter::new()
            .with_skill("research", arc_named("research-chain"))
            .with_skill("summarize", arc_named("summary-chain"));

        assert!(router.chain_for("research").is_some());
        assert!(router.chain_for("summarize").is_some());
        // Unknown skill falls through to the default chain.
        assert!(router.chain_for("nope").is_none());
        // Distinct chains per skill.
        let a = router.chain_for("research").unwrap();
        let b = router.chain_for("summarize").unwrap();
        assert_ne!(a.name(), b.name());
    }
}