lash_standard_plugins/
lib.rs

1pub mod rolling_history;
2
3use std::sync::Arc;
4
5use lash_core::plugin::{PluginSpec, StaticPluginFactory};
6use lash_core::{PluginStack, ToolProvider};
7pub use lash_plugin_observational_memory::ObservationalMemoryConfig;
8use lash_plugin_observational_memory::ObservationalMemoryPluginFactory;
9use lash_plugin_process_controls::SessionProcessAdminPluginFactory;
10use lash_plugin_tool_discovery::ToolDiscoveryPluginFactory;
11use lash_plugin_tool_output_budget::{ToolOutputBudgetPluginFactory, tool_output_budget_stack};
12use lash_tools::apply_patch::apply_patch_provider;
13use lash_tools::files::{glob_provider, read_file_provider};
14use lash_tools::shell::StandardShellPluginFactory;
15use lash_tools::web::{fetch_url_provider, web_search_provider};
16pub use rolling_history::RollingHistoryConfig;
17use rolling_history::RollingHistoryPluginFactory;
18
19#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
20pub enum StandardContextApproachKind {
21    RollingHistory,
22    ObservationalMemory,
23}
24
25#[derive(Clone, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
26#[serde(tag = "kind", rename_all = "snake_case")]
27pub enum StandardContextApproach {
28    RollingHistory(RollingHistoryConfig),
29    ObservationalMemory(ObservationalMemoryConfig),
30}
31
32impl Default for StandardContextApproach {
33    fn default() -> Self {
34        Self::RollingHistory(RollingHistoryConfig)
35    }
36}
37
38impl StandardContextApproach {
39    pub fn kind(&self) -> StandardContextApproachKind {
40        match self {
41            Self::RollingHistory(_) => StandardContextApproachKind::RollingHistory,
42            Self::ObservationalMemory(_) => StandardContextApproachKind::ObservationalMemory,
43        }
44    }
45}
46
47#[derive(Clone, Debug)]
48pub struct StandardToolStackOptions {
49    pub standard_context_approach: Option<StandardContextApproach>,
50    pub tavily_api_key: Option<String>,
51    pub include_cancel_process: bool,
52}
53
54impl Default for StandardToolStackOptions {
55    fn default() -> Self {
56        Self {
57            standard_context_approach: None,
58            tavily_api_key: None,
59            include_cancel_process: true,
60        }
61    }
62}
63
64pub fn standard_tool_stack(options: StandardToolStackOptions) -> PluginStack {
65    let mut stack = PluginStack::new();
66    push_core_runtime_tools(&mut stack);
67    push_standard_context_tools(&mut stack, options.standard_context_approach.as_ref());
68    push_local_runtime_tools(&mut stack, options.include_cancel_process);
69    if let Some(key) = options.tavily_api_key {
70        push_web_tools(&mut stack, key);
71    }
72    stack
73}
74
75pub fn locked_down_rlm_plugin_stack() -> PluginStack {
76    tool_output_budget_stack()
77}
78
79fn push_core_runtime_tools(stack: &mut PluginStack) {
80    stack.push(Arc::new(ToolDiscoveryPluginFactory::new()));
81    stack.push(Arc::new(ToolOutputBudgetPluginFactory::default()));
82}
83
84fn push_standard_context_tools(
85    stack: &mut PluginStack,
86    standard_context_approach: Option<&StandardContextApproach>,
87) {
88    match standard_context_approach {
89        Some(StandardContextApproach::RollingHistory(config)) => {
90            stack.push(Arc::new(RollingHistoryPluginFactory::new(config.clone())));
91        }
92        Some(StandardContextApproach::ObservationalMemory(config)) => {
93            stack.push(Arc::new(ObservationalMemoryPluginFactory::new(
94                config.clone(),
95            )));
96        }
97        None => {}
98    }
99}
100
101fn push_local_runtime_tools(stack: &mut PluginStack, include_cancel_process: bool) {
102    let processess = if include_cancel_process {
103        SessionProcessAdminPluginFactory::new()
104    } else {
105        SessionProcessAdminPluginFactory::without_cancel_process()
106    };
107    stack.push(Arc::new(processess));
108    stack.push(Arc::new(StandardShellPluginFactory::new()));
109    stack.push(Arc::new(StaticPluginFactory::new(
110        "apply_patch",
111        PluginSpec::new()
112            .with_tool_provider(Arc::new(apply_patch_provider()) as Arc<dyn ToolProvider>),
113    )));
114    stack.push(Arc::new(StaticPluginFactory::new(
115        "read_file",
116        PluginSpec::new()
117            .with_tool_provider(Arc::new(read_file_provider()) as Arc<dyn ToolProvider>),
118    )));
119    stack.push(Arc::new(StaticPluginFactory::new(
120        "glob",
121        PluginSpec::new().with_tool_provider(Arc::new(glob_provider()) as Arc<dyn ToolProvider>),
122    )));
123}
124
125fn push_web_tools(stack: &mut PluginStack, tavily_api_key: String) {
126    let search_key = tavily_api_key.clone();
127    stack.push(Arc::new(StaticPluginFactory::new(
128        "search_web",
129        PluginSpec::new()
130            .with_tool_provider(Arc::new(web_search_provider(search_key)) as Arc<dyn ToolProvider>),
131    )));
132    stack.push(Arc::new(StaticPluginFactory::new(
133        "fetch_url",
134        PluginSpec::new().with_tool_provider(
135            Arc::new(fetch_url_provider(tavily_api_key)) as Arc<dyn ToolProvider>
136        ),
137    )));
138}
139
140#[cfg(test)]
141mod tests {
142    use super::*;
143
144    fn stack_ids(stack: &PluginStack) -> Vec<&'static str> {
145        stack
146            .factories()
147            .iter()
148            .map(|factory| factory.id())
149            .collect()
150    }
151
152    fn tool_names_for_stack(
153        protocol_factories: Vec<Arc<dyn lash_core::plugin::PluginFactory>>,
154        standard_context_approach: Option<StandardContextApproach>,
155        include_cancel_process: bool,
156    ) -> Vec<String> {
157        let mut factories = standard_tool_stack(StandardToolStackOptions {
158            standard_context_approach: standard_context_approach.clone(),
159            include_cancel_process,
160            ..Default::default()
161        })
162        .into_factories();
163        factories.extend(protocol_factories);
164        let host = lash_core::PluginHost::new(factories);
165        let session_id = "test".to_string();
166        let session = host
167            .build_session(session_id.clone(), None)
168            .expect("session");
169        session
170            .resolved_tool_catalog(&session_id)
171            .expect("tool catalog")
172            .tool_names()
173            .as_ref()
174            .clone()
175    }
176
177    #[test]
178    fn rolling_history_context_installs_rolling_history_only() {
179        let stack = standard_tool_stack(StandardToolStackOptions {
180            standard_context_approach: Some(StandardContextApproach::RollingHistory(
181                Default::default(),
182            )),
183            tavily_api_key: None,
184            include_cancel_process: true,
185        });
186        let ids = stack_ids(&stack);
187
188        assert!(ids.contains(&"rolling_history"));
189        assert!(!ids.contains(&"observational_memory"));
190    }
191
192    #[test]
193    fn observational_memory_context_installs_om_support() {
194        let stack = standard_tool_stack(StandardToolStackOptions {
195            standard_context_approach: Some(StandardContextApproach::ObservationalMemory(
196                Default::default(),
197            )),
198            tavily_api_key: None,
199            include_cancel_process: true,
200        });
201        let ids = stack_ids(&stack);
202        assert!(ids.contains(&"observational_memory"));
203    }
204
205    #[test]
206    fn web_tools_are_explicitly_keyed() {
207        let without_web = stack_ids(&standard_tool_stack(StandardToolStackOptions::default()));
208        let with_web = stack_ids(&standard_tool_stack(StandardToolStackOptions {
209            tavily_api_key: Some("key".to_string()),
210            ..Default::default()
211        }));
212
213        assert!(!without_web.contains(&"search_web"));
214        assert!(with_web.contains(&"search_web"));
215        assert!(with_web.contains(&"fetch_url"));
216    }
217
218    #[test]
219    fn standard_stack_does_not_install_cli_local_grep() {
220        let ids = stack_ids(&standard_tool_stack(StandardToolStackOptions::default()));
221
222        assert!(!ids.contains(&"grep"));
223    }
224
225    #[test]
226    fn standard_stack_exposes_glob_and_read_without_ls() {
227        let names = tool_names_for_stack(
228            lash_core::testing::test_standard_protocol_factories(),
229            None,
230            true,
231        );
232
233        assert!(names.contains(&"glob".to_string()));
234        assert!(names.contains(&"read_file".to_string()));
235        assert!(!names.contains(&"ls".to_string()));
236    }
237
238    #[test]
239    fn shared_stack_exposes_process_list_in_rlm_without_cancel_tool() {
240        let standard_names = tool_names_for_stack(
241            lash_core::testing::test_standard_protocol_factories(),
242            Some(StandardContextApproach::default()),
243            true,
244        );
245        let rlm_names = tool_names_for_stack(
246            lash_core::testing::test_code_protocol_factories(),
247            None,
248            false,
249        );
250
251        assert!(standard_names.contains(&"list_process_handles".to_string()));
252        assert!(standard_names.contains(&"cancel_process".to_string()));
253        assert!(rlm_names.contains(&"list_process_handles".to_string()));
254        assert!(!rlm_names.contains(&"cancel_process".to_string()));
255    }
256}
lash_standard_plugins/lib.rs

lash_standard_plugins/
lib.rs
