tirea-agentos 0.4.0

Agent runtime with streaming LLM integration, sub-agent orchestration, and context window management
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
123

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

use crate::composition::ToolRegistry;
use crate::contracts::runtime::tool_call::Tool;

pub use tirea_extension_mcp::*;

impl ToolRegistry for tirea_extension_mcp::McpToolRegistry {
    fn len(&self) -> usize {
        tirea_extension_mcp::McpToolRegistry::len(self)
    }

    fn get(&self, id: &str) -> Option<Arc<dyn Tool>> {
        tirea_extension_mcp::McpToolRegistry::get(self, id)
    }

    fn ids(&self) -> Vec<String> {
        tirea_extension_mcp::McpToolRegistry::ids(self)
    }

    fn snapshot(&self) -> HashMap<String, Arc<dyn Tool>> {
        tirea_extension_mcp::McpToolRegistry::snapshot(self)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use async_trait::async_trait;
    use mcp::transport::{McpServerConnectionConfig, McpTransportError, TransportTypeId};
    use mcp::McpToolDefinition;
    use serde_json::Value;
    use std::sync::{Arc, Mutex};
    use tokio::sync::mpsc;

    use crate::composition::{AgentDefinition, AgentDefinitionSpec};
    use crate::runtime::AgentOs;

    #[derive(Debug, Clone)]
    struct MutableTransport {
        tools: Arc<Mutex<Vec<McpToolDefinition>>>,
    }

    impl MutableTransport {
        fn new(tools: Vec<McpToolDefinition>) -> Self {
            Self {
                tools: Arc::new(Mutex::new(tools)),
            }
        }

        fn replace(&self, tools: Vec<McpToolDefinition>) {
            match self.tools.lock() {
                Ok(mut guard) => *guard = tools,
                Err(poisoned) => *poisoned.into_inner() = tools,
            }
        }
    }

    #[async_trait]
    impl McpToolTransport for MutableTransport {
        async fn list_tools(&self) -> Result<Vec<McpToolDefinition>, McpTransportError> {
            let tools = match self.tools.lock() {
                Ok(guard) => guard.clone(),
                Err(poisoned) => poisoned.into_inner().clone(),
            };
            Ok(tools)
        }

        async fn call_tool(
            &self,
            _name: &str,
            _args: Value,
            _progress_tx: Option<mpsc::UnboundedSender<McpProgressUpdate>>,
        ) -> Result<mcp::CallToolResult, McpTransportError> {
            Ok(mcp::CallToolResult {
                content: vec![mcp::ToolContent::text("ok")],
                structured_content: None,
                is_error: None,
            })
        }

        fn transport_type(&self) -> TransportTypeId {
            TransportTypeId::Stdio
        }
    }

    fn cfg(name: &str) -> McpServerConnectionConfig {
        McpServerConnectionConfig::stdio(name, "unused", vec![])
    }

    #[tokio::test]
    async fn mcp_registry_implements_dynamic_tool_registry() {
        let transport = Arc::new(MutableTransport::new(vec![McpToolDefinition::new("echo")]));
        let manager = McpToolRegistryManager::from_transports([(
            cfg("mcp_s1"),
            transport.clone() as Arc<dyn McpToolTransport>,
        )])
        .await
        .expect("build manager");
        let registry = Arc::new(manager.registry()) as Arc<dyn ToolRegistry>;

        let os = AgentOs::builder()
            .with_agent_spec(AgentDefinitionSpec::local_with_id(
                "assistant",
                AgentDefinition::new("gpt-4o-mini"),
            ))
            .with_tool_registry(registry)
            .build()
            .expect("build agent os");

        let resolved1 = os.resolve("assistant").expect("resolve first snapshot");
        assert!(resolved1.tools.contains_key("mcp__mcp_s1__echo"));
        assert!(!resolved1.tools.contains_key("mcp__mcp_s1__sum"));

        transport.replace(vec![McpToolDefinition::new("sum")]);
        manager.refresh().await.expect("refresh registry");

        let resolved2 = os.resolve("assistant").expect("resolve refreshed snapshot");
        assert!(!resolved2.tools.contains_key("mcp__mcp_s1__echo"));
        assert!(resolved2.tools.contains_key("mcp__mcp_s1__sum"));
    }
}