apollo-agent 0.6.0

Local-first Rust AI agent runtime — Telegram-first, trait-driven, SurrealDB + RocksDB state layer.
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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

//! Microsoft Teams channel — Bot Framework integration

use async_trait::async_trait;
use serde_json::Value;
use tokio::sync::mpsc;

use super::traits::*;

pub struct TeamsChannel {
    app_id: String,
    app_password: String,
    token_url: String,
    service_base: String,
    bind_addr: std::net::SocketAddr,
}

impl TeamsChannel {
    pub fn new(app_id: impl Into<String>, app_password: impl Into<String>) -> Self {
        Self {
            app_id: app_id.into(),
            app_password: app_password.into(),
            token_url: "https://login.microsoftonline.com/botframework.com/oauth2/v2.0/token"
                .to_string(),
            service_base: "https://smba.trafficmanager.net/teams/v3".to_string(),
            bind_addr: ([0, 0, 0, 0], 3978).into(),
        }
    }

    /// Point the Bot Framework token + service endpoints at another origin
    /// (conformance tests).
    pub fn with_api_base(mut self, base: impl Into<String>) -> Self {
        let base = base.into().trim_end_matches('/').to_string();
        self.token_url = format!("{base}/oauth2/v2.0/token");
        self.service_base = format!("{base}/teams/v3");
        self
    }

    /// Bind the Bot Framework receiver somewhere other than 0.0.0.0:3978.
    pub fn with_bind_addr(mut self, addr: std::net::SocketAddr) -> Self {
        self.bind_addr = addr;
        self
    }
}

#[async_trait]
impl Channel for TeamsChannel {
    fn name(&self) -> &str {
        "msteams"
    }

    async fn start(&mut self) -> anyhow::Result<mpsc::Receiver<IncomingMessage>> {
        let (tx, rx) = mpsc::channel(32);
        let _app_id = self.app_id.clone();
        super::webhook::serve_json(self.bind_addr, "/api/messages", parse_activity, tx).await?;
        Ok(rx)
    }

    async fn send(&self, message: OutgoingMessage) -> anyhow::Result<Option<String>> {
        let client = crate::http::shared();

        // Get Bot Framework token
        let token_resp = client
            .post(&self.token_url)
            .form(&[
                ("grant_type", "client_credentials"),
                ("client_id", &self.app_id),
                ("client_secret", &self.app_password),
                ("scope", "https://api.botframework.com/.default"),
            ])
            .send()
            .await?;

        let token_data: Value = token_resp.json().await?;
        let token = token_data["access_token"].as_str().unwrap_or("");

        let body = serde_json::json!({
            "type": "message",
            "text": &message.text,
        });

        client
            .post(format!(
                "{}/conversations/{}/activities",
                self.service_base, message.chat_id
            ))
            .header("Authorization", format!("Bearer {}", token))
            .json(&body)
            .send()
            .await?;

        Ok(None)
    }

    async fn stop(&mut self) -> anyhow::Result<()> {
        Ok(())
    }
}

/// Bot Framework activity → apollo message. Only `message` activities carry
/// user text; the rest (typing, conversationUpdate) are ignored.
fn parse_activity(body: &Value) -> Vec<IncomingMessage> {
    if body["type"].as_str() != Some("message") {
        return Vec::new();
    }
    let text = body["text"].as_str().unwrap_or("").to_string();
    if text.is_empty() {
        return Vec::new();
    }
    vec![IncomingMessage {
        id: body["id"].as_str().unwrap_or("").to_string(),
        sender_id: body["from"]["id"].as_str().unwrap_or("").to_string(),
        sender_name: body["from"]["name"].as_str().map(|s| s.to_string()),
        chat_id: body["conversation"]["id"]
            .as_str()
            .unwrap_or("")
            .to_string(),
        text,
        is_group: body["conversation"]["conversationType"].as_str() == Some("groupChat"),
        reply_to: None,
        timestamp: chrono::Utc::now(),
    }]
}