1pub mod wit;
2
3use crate::ExtensionManifest;
4use anyhow::{Context as _, Result, anyhow, bail};
5use async_trait::async_trait;
6use extension::{
7 CodeLabel, Command, Completion, ContextServerConfiguration, DebugAdapterBinary,
8 DebugTaskDefinition, ExtensionHostProxy, KeyValueStoreDelegate, ProjectDelegate, SlashCommand,
9 SlashCommandArgumentCompletion, SlashCommandOutput, Symbol, WorktreeDelegate,
10};
11use fs::{Fs, normalize_path};
12use futures::future::LocalBoxFuture;
13use futures::{
14 Future, FutureExt, StreamExt as _,
15 channel::{
16 mpsc::{self, UnboundedSender},
17 oneshot,
18 },
19 future::BoxFuture,
20};
21use gpui::{App, AsyncApp, BackgroundExecutor, Task};
22use http_client::HttpClient;
23use language::LanguageName;
24use lsp::LanguageServerName;
25use moka::sync::Cache;
26use node_runtime::NodeRuntime;
27use release_channel::ReleaseChannel;
28use semantic_version::SemanticVersion;
29use std::borrow::Cow;
30use std::sync::LazyLock;
31use std::{
32 path::{Path, PathBuf},
33 sync::Arc,
34};
35use wasmtime::{
36 CacheStore, Engine, Store,
37 component::{Component, ResourceTable},
38};
39use wasmtime_wasi::{self as wasi, WasiView};
40use wit::Extension;
41
42pub struct WasmHost {
43 engine: Engine,
44 release_channel: ReleaseChannel,
45 http_client: Arc<dyn HttpClient>,
46 node_runtime: NodeRuntime,
47 pub(crate) proxy: Arc<ExtensionHostProxy>,
48 fs: Arc<dyn Fs>,
49 pub work_dir: PathBuf,
50 _main_thread_message_task: Task<()>,
51 main_thread_message_tx: mpsc::UnboundedSender<MainThreadCall>,
52}
53
54#[derive(Clone)]
55pub struct WasmExtension {
56 tx: UnboundedSender<ExtensionCall>,
57 pub manifest: Arc<ExtensionManifest>,
58 pub work_dir: Arc<Path>,
59 #[allow(unused)]
60 pub zed_api_version: SemanticVersion,
61}
62
63#[async_trait]
64impl extension::Extension for WasmExtension {
65 fn manifest(&self) -> Arc<ExtensionManifest> {
66 self.manifest.clone()
67 }
68
69 fn work_dir(&self) -> Arc<Path> {
70 self.work_dir.clone()
71 }
72
73 async fn language_server_command(
74 &self,
75 language_server_id: LanguageServerName,
76 language_name: LanguageName,
77 worktree: Arc<dyn WorktreeDelegate>,
78 ) -> Result<Command> {
79 self.call(|extension, store| {
80 async move {
81 let resource = store.data_mut().table().push(worktree)?;
82 let command = extension
83 .call_language_server_command(
84 store,
85 &language_server_id,
86 &language_name,
87 resource,
88 )
89 .await?
90 .map_err(|err| anyhow!("{err}"))?;
91
92 Ok(command.into())
93 }
94 .boxed()
95 })
96 .await
97 }
98
99 async fn language_server_initialization_options(
100 &self,
101 language_server_id: LanguageServerName,
102 language_name: LanguageName,
103 worktree: Arc<dyn WorktreeDelegate>,
104 ) -> Result<Option<String>> {
105 self.call(|extension, store| {
106 async move {
107 let resource = store.data_mut().table().push(worktree)?;
108 let options = extension
109 .call_language_server_initialization_options(
110 store,
111 &language_server_id,
112 &language_name,
113 resource,
114 )
115 .await?
116 .map_err(|err| anyhow!("{err}"))?;
117 anyhow::Ok(options)
118 }
119 .boxed()
120 })
121 .await
122 }
123
124 async fn language_server_workspace_configuration(
125 &self,
126 language_server_id: LanguageServerName,
127 worktree: Arc<dyn WorktreeDelegate>,
128 ) -> Result<Option<String>> {
129 self.call(|extension, store| {
130 async move {
131 let resource = store.data_mut().table().push(worktree)?;
132 let options = extension
133 .call_language_server_workspace_configuration(
134 store,
135 &language_server_id,
136 resource,
137 )
138 .await?
139 .map_err(|err| anyhow!("{err}"))?;
140 anyhow::Ok(options)
141 }
142 .boxed()
143 })
144 .await
145 }
146
147 async fn language_server_additional_initialization_options(
148 &self,
149 language_server_id: LanguageServerName,
150 target_language_server_id: LanguageServerName,
151 worktree: Arc<dyn WorktreeDelegate>,
152 ) -> Result<Option<String>> {
153 self.call(|extension, store| {
154 async move {
155 let resource = store.data_mut().table().push(worktree)?;
156 let options = extension
157 .call_language_server_additional_initialization_options(
158 store,
159 &language_server_id,
160 &target_language_server_id,
161 resource,
162 )
163 .await?
164 .map_err(|err| anyhow!("{err}"))?;
165 anyhow::Ok(options)
166 }
167 .boxed()
168 })
169 .await
170 }
171
172 async fn language_server_additional_workspace_configuration(
173 &self,
174 language_server_id: LanguageServerName,
175 target_language_server_id: LanguageServerName,
176 worktree: Arc<dyn WorktreeDelegate>,
177 ) -> Result<Option<String>> {
178 self.call(|extension, store| {
179 async move {
180 let resource = store.data_mut().table().push(worktree)?;
181 let options = extension
182 .call_language_server_additional_workspace_configuration(
183 store,
184 &language_server_id,
185 &target_language_server_id,
186 resource,
187 )
188 .await?
189 .map_err(|err| anyhow!("{err}"))?;
190 anyhow::Ok(options)
191 }
192 .boxed()
193 })
194 .await
195 }
196
197 async fn labels_for_completions(
198 &self,
199 language_server_id: LanguageServerName,
200 completions: Vec<Completion>,
201 ) -> Result<Vec<Option<CodeLabel>>> {
202 self.call(|extension, store| {
203 async move {
204 let labels = extension
205 .call_labels_for_completions(
206 store,
207 &language_server_id,
208 completions.into_iter().map(Into::into).collect(),
209 )
210 .await?
211 .map_err(|err| anyhow!("{err}"))?;
212
213 Ok(labels
214 .into_iter()
215 .map(|label| label.map(Into::into))
216 .collect())
217 }
218 .boxed()
219 })
220 .await
221 }
222
223 async fn labels_for_symbols(
224 &self,
225 language_server_id: LanguageServerName,
226 symbols: Vec<Symbol>,
227 ) -> Result<Vec<Option<CodeLabel>>> {
228 self.call(|extension, store| {
229 async move {
230 let labels = extension
231 .call_labels_for_symbols(
232 store,
233 &language_server_id,
234 symbols.into_iter().map(Into::into).collect(),
235 )
236 .await?
237 .map_err(|err| anyhow!("{err}"))?;
238
239 Ok(labels
240 .into_iter()
241 .map(|label| label.map(Into::into))
242 .collect())
243 }
244 .boxed()
245 })
246 .await
247 }
248
249 async fn complete_slash_command_argument(
250 &self,
251 command: SlashCommand,
252 arguments: Vec<String>,
253 ) -> Result<Vec<SlashCommandArgumentCompletion>> {
254 self.call(|extension, store| {
255 async move {
256 let completions = extension
257 .call_complete_slash_command_argument(store, &command.into(), &arguments)
258 .await?
259 .map_err(|err| anyhow!("{err}"))?;
260
261 Ok(completions.into_iter().map(Into::into).collect())
262 }
263 .boxed()
264 })
265 .await
266 }
267
268 async fn run_slash_command(
269 &self,
270 command: SlashCommand,
271 arguments: Vec<String>,
272 delegate: Option<Arc<dyn WorktreeDelegate>>,
273 ) -> Result<SlashCommandOutput> {
274 self.call(|extension, store| {
275 async move {
276 let resource = if let Some(delegate) = delegate {
277 Some(store.data_mut().table().push(delegate)?)
278 } else {
279 None
280 };
281
282 let output = extension
283 .call_run_slash_command(store, &command.into(), &arguments, resource)
284 .await?
285 .map_err(|err| anyhow!("{err}"))?;
286
287 Ok(output.into())
288 }
289 .boxed()
290 })
291 .await
292 }
293
294 async fn context_server_command(
295 &self,
296 context_server_id: Arc<str>,
297 project: Arc<dyn ProjectDelegate>,
298 ) -> Result<Command> {
299 self.call(|extension, store| {
300 async move {
301 let project_resource = store.data_mut().table().push(project)?;
302 let command = extension
303 .call_context_server_command(store, context_server_id.clone(), project_resource)
304 .await?
305 .map_err(|err| anyhow!("{err}"))?;
306 anyhow::Ok(command.into())
307 }
308 .boxed()
309 })
310 .await
311 }
312
313 async fn context_server_configuration(
314 &self,
315 context_server_id: Arc<str>,
316 project: Arc<dyn ProjectDelegate>,
317 ) -> Result<Option<ContextServerConfiguration>> {
318 self.call(|extension, store| {
319 async move {
320 let project_resource = store.data_mut().table().push(project)?;
321 let Some(configuration) = extension
322 .call_context_server_configuration(
323 store,
324 context_server_id.clone(),
325 project_resource,
326 )
327 .await?
328 .map_err(|err| anyhow!("{err}"))?
329 else {
330 return Ok(None);
331 };
332
333 Ok(Some(configuration.try_into()?))
334 }
335 .boxed()
336 })
337 .await
338 }
339
340 async fn suggest_docs_packages(&self, provider: Arc<str>) -> Result<Vec<String>> {
341 self.call(|extension, store| {
342 async move {
343 let packages = extension
344 .call_suggest_docs_packages(store, provider.as_ref())
345 .await?
346 .map_err(|err| anyhow!("{err:?}"))?;
347
348 Ok(packages)
349 }
350 .boxed()
351 })
352 .await
353 }
354
355 async fn index_docs(
356 &self,
357 provider: Arc<str>,
358 package_name: Arc<str>,
359 kv_store: Arc<dyn KeyValueStoreDelegate>,
360 ) -> Result<()> {
361 self.call(|extension, store| {
362 async move {
363 let kv_store_resource = store.data_mut().table().push(kv_store)?;
364 extension
365 .call_index_docs(
366 store,
367 provider.as_ref(),
368 package_name.as_ref(),
369 kv_store_resource,
370 )
371 .await?
372 .map_err(|err| anyhow!("{err:?}"))?;
373
374 anyhow::Ok(())
375 }
376 .boxed()
377 })
378 .await
379 }
380 async fn get_dap_binary(
381 &self,
382 dap_name: Arc<str>,
383 config: DebugTaskDefinition,
384 user_installed_path: Option<PathBuf>,
385 worktree: Arc<dyn WorktreeDelegate>,
386 ) -> Result<DebugAdapterBinary> {
387 self.call(|extension, store| {
388 async move {
389 let resource = store.data_mut().table().push(worktree)?;
390 let dap_binary = extension
391 .call_get_dap_binary(store, dap_name, config, user_installed_path, resource)
392 .await?
393 .map_err(|err| anyhow!("{err:?}"))?;
394 let dap_binary = dap_binary.try_into()?;
395 Ok(dap_binary)
396 }
397 .boxed()
398 })
399 .await
400 }
401}
402
403pub struct WasmState {
404 manifest: Arc<ExtensionManifest>,
405 pub table: ResourceTable,
406 ctx: wasi::WasiCtx,
407 pub host: Arc<WasmHost>,
408}
409
410type MainThreadCall = Box<dyn Send + for<'a> FnOnce(&'a mut AsyncApp) -> LocalBoxFuture<'a, ()>>;
411
412type ExtensionCall = Box<
413 dyn Send + for<'a> FnOnce(&'a mut Extension, &'a mut Store<WasmState>) -> BoxFuture<'a, ()>,
414>;
415
416fn wasm_engine() -> wasmtime::Engine {
417 static WASM_ENGINE: LazyLock<wasmtime::Engine> = LazyLock::new(|| {
418 let mut config = wasmtime::Config::new();
419 config.wasm_component_model(true);
420 config.async_support(true);
421 config
422 .enable_incremental_compilation(cache_store())
423 .unwrap();
424 wasmtime::Engine::new(&config).unwrap()
425 });
426
427 WASM_ENGINE.clone()
428}
429
430fn cache_store() -> Arc<IncrementalCompilationCache> {
431 static CACHE_STORE: LazyLock<Arc<IncrementalCompilationCache>> =
432 LazyLock::new(|| Arc::new(IncrementalCompilationCache::new()));
433 CACHE_STORE.clone()
434}
435
436impl WasmHost {
437 pub fn new(
438 fs: Arc<dyn Fs>,
439 http_client: Arc<dyn HttpClient>,
440 node_runtime: NodeRuntime,
441 proxy: Arc<ExtensionHostProxy>,
442 work_dir: PathBuf,
443 cx: &mut App,
444 ) -> Arc<Self> {
445 let (tx, mut rx) = mpsc::unbounded::<MainThreadCall>();
446 let task = cx.spawn(async move |cx| {
447 while let Some(message) = rx.next().await {
448 message(cx).await;
449 }
450 });
451 Arc::new(Self {
452 engine: wasm_engine(),
453 fs,
454 work_dir,
455 http_client,
456 node_runtime,
457 proxy,
458 release_channel: ReleaseChannel::global(cx),
459 _main_thread_message_task: task,
460 main_thread_message_tx: tx,
461 })
462 }
463
464 pub fn load_extension(
465 self: &Arc<Self>,
466 wasm_bytes: Vec<u8>,
467 manifest: &Arc<ExtensionManifest>,
468 executor: BackgroundExecutor,
469 ) -> Task<Result<WasmExtension>> {
470 let this = self.clone();
471 let manifest = manifest.clone();
472 executor.clone().spawn(async move {
473 let zed_api_version = parse_wasm_extension_version(&manifest.id, &wasm_bytes)?;
474
475 let component = Component::from_binary(&this.engine, &wasm_bytes)
476 .context("failed to compile wasm component")?;
477
478 let mut store = wasmtime::Store::new(
479 &this.engine,
480 WasmState {
481 ctx: this.build_wasi_ctx(&manifest).await?,
482 manifest: manifest.clone(),
483 table: ResourceTable::new(),
484 host: this.clone(),
485 },
486 );
487
488 let mut extension = Extension::instantiate_async(
489 &mut store,
490 this.release_channel,
491 zed_api_version,
492 &component,
493 )
494 .await?;
495
496 extension
497 .call_init_extension(&mut store)
498 .await
499 .context("failed to initialize wasm extension")?;
500
501 let (tx, mut rx) = mpsc::unbounded::<ExtensionCall>();
502 executor
503 .spawn(async move {
504 while let Some(call) = rx.next().await {
505 (call)(&mut extension, &mut store).await;
506 }
507 })
508 .detach();
509
510 Ok(WasmExtension {
511 manifest: manifest.clone(),
512 work_dir: this.work_dir.join(manifest.id.as_ref()).into(),
513 tx,
514 zed_api_version,
515 })
516 })
517 }
518
519 async fn build_wasi_ctx(&self, manifest: &Arc<ExtensionManifest>) -> Result<wasi::WasiCtx> {
520 let extension_work_dir = self.work_dir.join(manifest.id.as_ref());
521 self.fs
522 .create_dir(&extension_work_dir)
523 .await
524 .context("failed to create extension work dir")?;
525
526 let file_perms = wasi::FilePerms::all();
527 let dir_perms = wasi::DirPerms::all();
528
529 Ok(wasi::WasiCtxBuilder::new()
530 .inherit_stdio()
531 .preopened_dir(&extension_work_dir, ".", dir_perms, file_perms)?
532 .preopened_dir(
533 &extension_work_dir,
534 extension_work_dir.to_string_lossy(),
535 dir_perms,
536 file_perms,
537 )?
538 .env("PWD", extension_work_dir.to_string_lossy())
539 .env("RUST_BACKTRACE", "full")
540 .build())
541 }
542
543 pub fn writeable_path_from_extension(&self, id: &Arc<str>, path: &Path) -> Result<PathBuf> {
544 let extension_work_dir = self.work_dir.join(id.as_ref());
545 let path = normalize_path(&extension_work_dir.join(path));
546 anyhow::ensure!(
547 path.starts_with(&extension_work_dir),
548 "cannot write to path {path:?}",
549 );
550 Ok(path)
551 }
552}
553
554pub fn parse_wasm_extension_version(
555 extension_id: &str,
556 wasm_bytes: &[u8],
557) -> Result<SemanticVersion> {
558 let mut version = None;
559
560 for part in wasmparser::Parser::new(0).parse_all(wasm_bytes) {
561 if let wasmparser::Payload::CustomSection(s) =
562 part.context("error parsing wasm extension")?
563 {
564 if s.name() == "zed:api-version" {
565 version = parse_wasm_extension_version_custom_section(s.data());
566 if version.is_none() {
567 bail!(
568 "extension {} has invalid zed:api-version section: {:?}",
569 extension_id,
570 s.data()
571 );
572 }
573 }
574 }
575 }
576
577 // The reason we wait until we're done parsing all of the Wasm bytes to return the version
578 // is to work around a panic that can happen inside of Wasmtime when the bytes are invalid.
579 //
580 // By parsing the entirety of the Wasm bytes before we return, we're able to detect this problem
581 // earlier as an `Err` rather than as a panic.
582 version.with_context(|| format!("extension {extension_id} has no zed:api-version section"))
583}
584
585fn parse_wasm_extension_version_custom_section(data: &[u8]) -> Option<SemanticVersion> {
586 if data.len() == 6 {
587 Some(SemanticVersion::new(
588 u16::from_be_bytes([data[0], data[1]]) as _,
589 u16::from_be_bytes([data[2], data[3]]) as _,
590 u16::from_be_bytes([data[4], data[5]]) as _,
591 ))
592 } else {
593 None
594 }
595}
596
597impl WasmExtension {
598 pub async fn load(
599 extension_dir: PathBuf,
600 manifest: &Arc<ExtensionManifest>,
601 wasm_host: Arc<WasmHost>,
602 cx: &AsyncApp,
603 ) -> Result<Self> {
604 let path = extension_dir.join("extension.wasm");
605
606 let mut wasm_file = wasm_host
607 .fs
608 .open_sync(&path)
609 .await
610 .context("failed to open wasm file")?;
611
612 let mut wasm_bytes = Vec::new();
613 wasm_file
614 .read_to_end(&mut wasm_bytes)
615 .context("failed to read wasm")?;
616
617 wasm_host
618 .load_extension(wasm_bytes, manifest, cx.background_executor().clone())
619 .await
620 .with_context(|| format!("failed to load wasm extension {}", manifest.id))
621 }
622
623 pub async fn call<T, Fn>(&self, f: Fn) -> T
624 where
625 T: 'static + Send,
626 Fn: 'static
627 + Send
628 + for<'a> FnOnce(&'a mut Extension, &'a mut Store<WasmState>) -> BoxFuture<'a, T>,
629 {
630 let (return_tx, return_rx) = oneshot::channel();
631 self.tx
632 .clone()
633 .unbounded_send(Box::new(move |extension, store| {
634 async {
635 let result = f(extension, store).await;
636 return_tx.send(result).ok();
637 }
638 .boxed()
639 }))
640 .expect("wasm extension channel should not be closed yet");
641 return_rx.await.expect("wasm extension channel")
642 }
643}
644
645impl WasmState {
646 fn on_main_thread<T, Fn>(&self, f: Fn) -> impl 'static + Future<Output = T>
647 where
648 T: 'static + Send,
649 Fn: 'static + Send + for<'a> FnOnce(&'a mut AsyncApp) -> LocalBoxFuture<'a, T>,
650 {
651 let (return_tx, return_rx) = oneshot::channel();
652 self.host
653 .main_thread_message_tx
654 .clone()
655 .unbounded_send(Box::new(move |cx| {
656 async {
657 let result = f(cx).await;
658 return_tx.send(result).ok();
659 }
660 .boxed_local()
661 }))
662 .expect("main thread message channel should not be closed yet");
663 async move { return_rx.await.expect("main thread message channel") }
664 }
665
666 fn work_dir(&self) -> PathBuf {
667 self.host.work_dir.join(self.manifest.id.as_ref())
668 }
669}
670
671impl wasi::WasiView for WasmState {
672 fn table(&mut self) -> &mut ResourceTable {
673 &mut self.table
674 }
675
676 fn ctx(&mut self) -> &mut wasi::WasiCtx {
677 &mut self.ctx
678 }
679}
680
681/// Wrapper around a mini-moka bounded cache for storing incremental compilation artifacts.
682/// Since wasm modules have many similar elements, this can save us a lot of work at the
683/// cost of a small memory footprint. However, we don't want this to be unbounded, so we use
684/// a LFU/LRU cache to evict less used cache entries.
685#[derive(Debug)]
686struct IncrementalCompilationCache {
687 cache: Cache<Vec<u8>, Vec<u8>>,
688}
689
690impl IncrementalCompilationCache {
691 fn new() -> Self {
692 let cache = Cache::builder()
693 // Cap this at 32 MB for now. Our extensions turn into roughly 512kb in the cache,
694 // which means we could store 64 completely novel extensions in the cache, but in
695 // practice we will more than that, which is more than enough for our use case.
696 .max_capacity(32 * 1024 * 1024)
697 .weigher(|k: &Vec<u8>, v: &Vec<u8>| (k.len() + v.len()).try_into().unwrap_or(u32::MAX))
698 .build();
699 Self { cache }
700 }
701}
702
703impl CacheStore for IncrementalCompilationCache {
704 fn get(&self, key: &[u8]) -> Option<Cow<[u8]>> {
705 self.cache.get(key).map(|v| v.into())
706 }
707
708 fn insert(&self, key: &[u8], value: Vec<u8>) -> bool {
709 self.cache.insert(key.to_vec(), value);
710 true
711 }
712}
713
714#[cfg(test)]
715mod tests {
716 use std::collections::BTreeMap;
717
718 use extension::{
719 ExtensionCapability, ExtensionLibraryKind, LanguageServerManifestEntry, LibManifestEntry,
720 SchemaVersion,
721 extension_builder::{CompileExtensionOptions, ExtensionBuilder},
722 };
723 use gpui::TestAppContext;
724 use reqwest_client::ReqwestClient;
725
726 use super::*;
727
728 #[gpui::test]
729 fn test_cache_size_for_test_extension(cx: &TestAppContext) {
730 let cache_store = cache_store();
731 let engine = wasm_engine();
732 let wasm_bytes = wasm_bytes(cx, &mut manifest());
733
734 Component::new(&engine, wasm_bytes).unwrap();
735
736 cache_store.cache.run_pending_tasks();
737 let size: usize = cache_store
738 .cache
739 .iter()
740 .map(|(k, v)| k.len() + v.len())
741 .sum();
742 // If this assertion fails, it means extensions got larger and we may want to
743 // reconsider our cache size.
744 assert!(size < 512 * 1024);
745 }
746
747 fn wasm_bytes(cx: &TestAppContext, manifest: &mut ExtensionManifest) -> Vec<u8> {
748 let extension_builder = extension_builder();
749 let path = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
750 .parent()
751 .unwrap()
752 .parent()
753 .unwrap()
754 .join("extensions/test-extension");
755 cx.executor()
756 .block(extension_builder.compile_extension(
757 &path,
758 manifest,
759 CompileExtensionOptions { release: true },
760 ))
761 .unwrap();
762 std::fs::read(path.join("extension.wasm")).unwrap()
763 }
764
765 fn extension_builder() -> ExtensionBuilder {
766 let user_agent = format!(
767 "Zed Extension CLI/{} ({}; {})",
768 env!("CARGO_PKG_VERSION"),
769 std::env::consts::OS,
770 std::env::consts::ARCH
771 );
772 let http_client = Arc::new(ReqwestClient::user_agent(&user_agent).unwrap());
773 // Local dir so that we don't have to download it on every run
774 let build_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("benches/.build");
775 ExtensionBuilder::new(http_client, build_dir)
776 }
777
778 fn manifest() -> ExtensionManifest {
779 ExtensionManifest {
780 id: "test-extension".into(),
781 name: "Test Extension".into(),
782 version: "0.1.0".into(),
783 schema_version: SchemaVersion(1),
784 description: Some("An extension for use in tests.".into()),
785 authors: Vec::new(),
786 repository: None,
787 themes: Default::default(),
788 icon_themes: Vec::new(),
789 lib: LibManifestEntry {
790 kind: Some(ExtensionLibraryKind::Rust),
791 version: Some(SemanticVersion::new(0, 1, 0)),
792 },
793 languages: Vec::new(),
794 grammars: BTreeMap::default(),
795 language_servers: [("gleam".into(), LanguageServerManifestEntry::default())]
796 .into_iter()
797 .collect(),
798 context_servers: BTreeMap::default(),
799 slash_commands: BTreeMap::default(),
800 indexed_docs_providers: BTreeMap::default(),
801 snippets: None,
802 capabilities: vec![ExtensionCapability::ProcessExec {
803 command: "echo".into(),
804 args: vec!["hello!".into()],
805 }],
806 }
807 }
808}