Bump to 0.162.4 for @ConradIrwin

Use our own git clone in draft release notes (#20956 )
It turns out that messing with the git repo created by the github action is tricky, so we'll just clone our own. On my machine, a shallow tree-less clone takes <500ms Release Notes: - N/A
2024-11-21 18:59:30 +00:00 · 2024-11-21 11:55:46 -07:00 · 2024-11-21 10:26:45 -07:00 · 2024-11-21 09:54:08 -07:00 · 2024-11-20 21:43:19 -07:00 · 2024-11-20 20:54:15 -07:00
74 changed files with 2888 additions and 1312 deletions
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -245,6 +245,7 @@ jobs:
          # 25 was chosen arbitrarily.
          fetch-depth: 25
          clean: false
+          ref: ${{ github.ref }}

      - name: Limit target directory size
        run: script/clear-target-dir-if-larger-than 100
@@ -261,6 +262,9 @@ jobs:
          mkdir -p target/
          # Ignore any errors that occur while drafting release notes to not fail the build.
          script/draft-release-notes "$RELEASE_VERSION" "$RELEASE_CHANNEL" > target/release-notes.md || true
+          script/create-draft-release target/release-notes.md
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

      - name: Generate license file
        run: script/generate-licenses
@@ -306,7 +310,6 @@ jobs:
            target/aarch64-apple-darwin/release/Zed-aarch64.dmg
            target/x86_64-apple-darwin/release/Zed-x86_64.dmg
            target/release/Zed.dmg
-          body_path: target/release-notes.md
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

@@ -353,7 +356,6 @@ jobs:
          files: |
            target/zed-remote-server-linux-x86_64.gz
            target/release/zed-linux-x86_64.tar.gz
-          body: ""
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

@@ -400,6 +402,5 @@ jobs:
          files: |
            target/zed-remote-server-linux-aarch64.gz
            target/release/zed-linux-aarch64.tar.gz
-          body: ""
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -459,8 +459,10 @@ name = "assistant_slash_command"
 version = "0.1.0"
 dependencies = [
 "anyhow",
+ "async-trait",
 "collections",
 "derive_more",
+ "extension",
 "futures 0.3.30",
 "gpui",
 "language",
@@ -469,6 +471,7 @@ dependencies = [
 "pretty_assertions",
 "serde",
 "serde_json",
+ "ui",
 "workspace",
 ]

@@ -2569,6 +2572,7 @@ dependencies = [
 "clock",
 "collab_ui",
 "collections",
+ "context_servers",
 "ctor",
 "dashmap 6.0.1",
 "derive_more",
@@ -2815,7 +2819,6 @@ name = "context_servers"
 version = "0.1.0"
 dependencies = [
 "anyhow",
- "async-trait",
 "collections",
 "command_palette_hooks",
 "futures 0.3.30",
@@ -4197,6 +4200,7 @@ dependencies = [
 "serde_json_lenient",
 "settings",
 "task",
+ "theme",
 "toml 0.8.19",
 "url",
 "util",
@@ -4211,36 +4215,26 @@ version = "0.1.0"
 dependencies = [
 "anyhow",
 "assistant_slash_command",
- "async-compression",
- "async-tar",
- "async-trait",
 "client",
 "collections",
 "context_servers",
- "ctor",
 "db",
 "editor",
- "env_logger 0.11.5",
 "extension",
 "extension_host",
 "fs",
- "futures 0.3.30",
 "fuzzy",
 "gpui",
- "http_client",
 "indexed_docs",
 "language",
+ "log",
 "lsp",
- "node_runtime",
 "num-format",
- "parking_lot",
 "picker",
 "project",
 "release_channel",
- "reqwest_client",
 "semantic_version",
 "serde",
- "serde_json",
 "settings",
 "smallvec",
 "snippet_provider",
@@ -5661,7 +5655,7 @@ dependencies = [
 "httpdate",
 "itoa",
 "pin-project-lite",
- "socket2 0.4.10",
+ "socket2 0.5.7",
 "tokio",
 "tower-service",
 "tracing",
@@ -15317,7 +15311,7 @@ dependencies = [

 [[package]]
 name = "zed"
-version = "0.162.0"
+version = "0.162.4"
 dependencies = [
 "activity_indicator",
 "anyhow",
--- a/assets/keymaps/default-linux.json
+++ b/assets/keymaps/default-linux.json
@@ -648,19 +648,23 @@
    }
  },
  {
-    "context": "FileFinder",
+    "context": "FileFinder && !menu_open",
    "bindings": {
      "ctrl-shift-p": "file_finder::SelectPrev",
-      "ctrl-k": "file_finder::OpenMenu"
+      "ctrl": "file_finder::OpenMenu",
+      "ctrl-j": "pane::SplitDown",
+      "ctrl-k": "pane::SplitUp",
+      "ctrl-h": "pane::SplitLeft",
+      "ctrl-l": "pane::SplitRight"
    }
  },
  {
    "context": "FileFinder && menu_open",
    "bindings": {
-      "u": "pane::SplitUp",
-      "d": "pane::SplitDown",
-      "l": "pane::SplitLeft",
-      "r": "pane::SplitRight"
+      "j": "pane::SplitDown",
+      "k": "pane::SplitUp",
+      "h": "pane::SplitLeft",
+      "l": "pane::SplitRight"
    }
  },
  {
--- a/assets/keymaps/default-macos.json
+++ b/assets/keymaps/default-macos.json
@@ -648,19 +648,23 @@
    }
  },
  {
-    "context": "FileFinder",
+    "context": "FileFinder && !menu_open",
    "bindings": {
      "cmd-shift-p": "file_finder::SelectPrev",
-      "cmd-k": "file_finder::OpenMenu"
+      "cmd": "file_finder::OpenMenu",
+      "cmd-j": "pane::SplitDown",
+      "cmd-k": "pane::SplitUp",
+      "cmd-h": "pane::SplitLeft",
+      "cmd-l": "pane::SplitRight"
    }
  },
  {
    "context": "FileFinder && menu_open",
    "bindings": {
-      "u": "pane::SplitUp",
-      "d": "pane::SplitDown",
-      "l": "pane::SplitLeft",
-      "r": "pane::SplitRight"
+      "j": "pane::SplitDown",
+      "k": "pane::SplitUp",
+      "h": "pane::SplitLeft",
+      "l": "pane::SplitRight"
    }
  },
  {
--- a/assets/settings/default.json
+++ b/assets/settings/default.json
@@ -157,7 +157,7 @@
  "auto_signature_help": false,
  /// Whether to show the signature help after completion or a bracket pair inserted.
  /// If `auto_signature_help` is enabled, this setting will be treated as enabled also.
-  "show_signature_help_after_edits": true,
+  "show_signature_help_after_edits": false,
  // Whether to show wrap guides (vertical rulers) in the editor.
  // Setting this to true will show a guide at the 'preferred_line_length' value
  // if 'soft_wrap' is set to 'preferred_line_length', and will show any
--- a/crates/assistant/src/assistant_panel.rs
+++ b/crates/assistant/src/assistant_panel.rs
@@ -2051,30 +2051,6 @@ impl ContextEditor {
            ContextEvent::SlashCommandOutputSectionAdded { section } => {
                self.insert_slash_command_output_sections([section.clone()], false, cx);
            }
-            ContextEvent::SlashCommandFinished {
-                output_range: _output_range,
-                run_commands_in_ranges,
-            } => {
-                for range in run_commands_in_ranges {
-                    let commands = self.context.update(cx, |context, cx| {
-                        context.reparse(cx);
-                        context
-                            .pending_commands_for_range(range.clone(), cx)
-                            .to_vec()
-                    });
-
-                    for command in commands {
-                        self.run_command(
-                            command.source_range,
-                            &command.name,
-                            &command.arguments,
-                            false,
-                            self.workspace.clone(),
-                            cx,
-                        );
-                    }
-                }
-            }
            ContextEvent::UsePendingTools => {
                let pending_tool_uses = self
                    .context
@@ -2153,6 +2129,37 @@ impl ContextEditor {
        command_id: InvokedSlashCommandId,
        cx: &mut ViewContext<Self>,
    ) {
+        if let Some(invoked_slash_command) =
+            self.context.read(cx).invoked_slash_command(&command_id)
+        {
+            if let InvokedSlashCommandStatus::Finished = invoked_slash_command.status {
+                let run_commands_in_ranges = invoked_slash_command
+                    .run_commands_in_ranges
+                    .iter()
+                    .cloned()
+                    .collect::<Vec<_>>();
+                for range in run_commands_in_ranges {
+                    let commands = self.context.update(cx, |context, cx| {
+                        context.reparse(cx);
+                        context
+                            .pending_commands_for_range(range.clone(), cx)
+                            .to_vec()
+                    });
+
+                    for command in commands {
+                        self.run_command(
+                            command.source_range,
+                            &command.name,
+                            &command.arguments,
+                            false,
+                            self.workspace.clone(),
+                            cx,
+                        );
+                    }
+                }
+            }
+        }
+
        self.editor.update(cx, |editor, cx| {
            if let Some(invoked_slash_command) =
                self.context.read(cx).invoked_slash_command(&command_id)
--- a/crates/assistant/src/context.rs
+++ b/crates/assistant/src/context.rs
@@ -381,10 +381,6 @@ pub enum ContextEvent {
    SlashCommandOutputSectionAdded {
        section: SlashCommandOutputSection<language::Anchor>,
    },
-    SlashCommandFinished {
-        output_range: Range<language::Anchor>,
-        run_commands_in_ranges: Vec<Range<language::Anchor>>,
-    },
    UsePendingTools,
    ToolFinished {
        tool_use_id: Arc<str>,
@@ -916,6 +912,7 @@ impl Context {
                        InvokedSlashCommand {
                            name: name.into(),
                            range: output_range,
+                            run_commands_in_ranges: Vec::new(),
                            status: InvokedSlashCommandStatus::Running(Task::ready(())),
                            transaction: None,
                            timestamp: id.0,
@@ -1914,7 +1911,6 @@ impl Context {
                }

                let mut pending_section_stack: Vec<PendingSection> = Vec::new();
-                let mut run_commands_in_ranges: Vec<Range<language::Anchor>> = Vec::new();
                let mut last_role: Option<Role> = None;
                let mut last_section_range = None;

@@ -1980,7 +1976,13 @@ impl Context {

                                let end = this.buffer.read(cx).anchor_before(insert_position);
                                if run_commands_in_text {
-                                    run_commands_in_ranges.push(start..end);
+                                    if let Some(invoked_slash_command) =
+                                        this.invoked_slash_commands.get_mut(&command_id)
+                                    {
+                                        invoked_slash_command
+                                            .run_commands_in_ranges
+                                            .push(start..end);
+                                    }
                                }
                            }
                            SlashCommandEvent::EndSection => {
@@ -2100,6 +2102,7 @@ impl Context {
            InvokedSlashCommand {
                name: name.to_string().into(),
                range: command_range.clone(),
+                run_commands_in_ranges: Vec::new(),
                status: InvokedSlashCommandStatus::Running(insert_output_task),
                transaction: Some(first_transaction),
                timestamp: command_id.0,
@@ -2887,7 +2890,7 @@ impl Context {
            request.messages.push(LanguageModelRequestMessage {
                role: Role::User,
                content: vec![
-                    "Generate a concise 3-7 word title for this conversation, omitting punctuation"
+                    "Generate a concise 3-7 word title for this conversation, omitting punctuation. Go straight to the title, without any preamble and prefix like `Here's a concise suggestion:...` or `Title:`"
                        .into(),
                ],
                cache: false,
@@ -3172,6 +3175,7 @@ pub struct ParsedSlashCommand {
 pub struct InvokedSlashCommand {
    pub name: SharedString,
    pub range: Range<language::Anchor>,
+    pub run_commands_in_ranges: Vec<Range<language::Anchor>>,
    pub status: InvokedSlashCommandStatus,
    pub transaction: Option<language::TransactionId>,
    timestamp: clock::Lamport,
--- a/crates/assistant/src/context_store.rs
+++ b/crates/assistant/src/context_store.rs
@@ -8,9 +8,8 @@ use anyhow::{anyhow, Context as _, Result};
 use client::{proto, telemetry::Telemetry, Client, TypedEnvelope};
 use clock::ReplicaId;
 use collections::HashMap;
-use command_palette_hooks::CommandPaletteFilter;
-use context_servers::manager::{ContextServerManager, ContextServerSettings};
-use context_servers::{ContextServerFactoryRegistry, CONTEXT_SERVERS_NAMESPACE};
+use context_servers::manager::ContextServerManager;
+use context_servers::ContextServerFactoryRegistry;
 use fs::Fs;
 use futures::StreamExt;
 use fuzzy::StringMatchCandidate;
@@ -22,7 +21,6 @@ use paths::contexts_dir;
 use project::Project;
 use regex::Regex;
 use rpc::AnyProtoClient;
-use settings::{Settings as _, SettingsStore};
 use std::{
    cmp::Reverse,
    ffi::OsStr,
@@ -111,7 +109,11 @@ impl ContextStore {
            let (mut events, _) = fs.watch(contexts_dir(), CONTEXT_WATCH_DURATION).await;

            let this = cx.new_model(|cx: &mut ModelContext<Self>| {
-                let context_server_manager = cx.new_model(|_cx| ContextServerManager::new());
+                let context_server_factory_registry =
+                    ContextServerFactoryRegistry::default_global(cx);
+                let context_server_manager = cx.new_model(|cx| {
+                    ContextServerManager::new(context_server_factory_registry, project.clone(), cx)
+                });
                let mut this = Self {
                    contexts: Vec::new(),
                    contexts_metadata: Vec::new(),
@@ -148,91 +150,16 @@ impl ContextStore {
                this.handle_project_changed(project.clone(), cx);
                this.synchronize_contexts(cx);
                this.register_context_server_handlers(cx);
-
-                if project.read(cx).is_local() {
-                    // TODO: At the time when we construct the `ContextStore` we may not have yet initialized the extensions.
-                    // In order to register the context servers when the extension is loaded, we're periodically looping to
-                    // see if there are context servers to register.
-                    //
-                    // I tried doing this in a subscription on the `ExtensionStore`, but it never seemed to fire.
-                    //
-                    // We should find a more elegant way to do this.
-                    let context_server_factory_registry =
-                        ContextServerFactoryRegistry::default_global(cx);
-                    cx.spawn(|context_store, mut cx| async move {
-                        loop {
-                            let mut servers_to_register = Vec::new();
-                            for (_id, factory) in
-                                context_server_factory_registry.context_server_factories()
-                            {
-                                if let Some(server) = factory(project.clone(), &cx).await.log_err()
-                                {
-                                    servers_to_register.push(server);
-                                }
-                            }
-
-                            let Some(_) = context_store
-                                .update(&mut cx, |this, cx| {
-                                    this.context_server_manager.update(cx, |this, cx| {
-                                        for server in servers_to_register {
-                                            this.add_server(server, cx).detach_and_log_err(cx);
-                                        }
-                                    })
-                                })
-                                .log_err()
-                            else {
-                                break;
-                            };
-
-                            smol::Timer::after(Duration::from_millis(100)).await;
-                        }
-
-                        anyhow::Ok(())
-                    })
-                    .detach_and_log_err(cx);
-                }
-
                this
            })?;
            this.update(&mut cx, |this, cx| this.reload(cx))?
                .await
                .log_err();

-            this.update(&mut cx, |this, cx| {
-                this.watch_context_server_settings(cx);
-            })
-            .log_err();
-
            Ok(this)
        })
    }

-    fn watch_context_server_settings(&self, cx: &mut ModelContext<Self>) {
-        cx.observe_global::<SettingsStore>(move |this, cx| {
-            this.context_server_manager.update(cx, |manager, cx| {
-                let location = this.project.read(cx).worktrees(cx).next().map(|worktree| {
-                    settings::SettingsLocation {
-                        worktree_id: worktree.read(cx).id(),
-                        path: Path::new(""),
-                    }
-                });
-                let settings = ContextServerSettings::get(location, cx);
-
-                manager.maintain_servers(settings, cx);
-
-                let has_any_context_servers = !manager.servers().is_empty();
-                CommandPaletteFilter::update_global(cx, |filter, _cx| {
-                    if has_any_context_servers {
-                        filter.show_namespace(CONTEXT_SERVERS_NAMESPACE);
-                    } else {
-                        filter.hide_namespace(CONTEXT_SERVERS_NAMESPACE);
-                    }
-                });
-            })
-        })
-        .detach();
-    }
-
    async fn handle_advertise_contexts(
        this: Model<Self>,
        envelope: TypedEnvelope<proto::AdvertiseContexts>,
--- a/crates/assistant/src/slash_command.rs
+++ b/crates/assistant/src/slash_command.rs
@@ -2,7 +2,7 @@ use crate::assistant_panel::ContextEditor;
 use crate::SlashCommandWorkingSet;
 use anyhow::Result;
 use assistant_slash_command::AfterCompletion;
-pub use assistant_slash_command::{SlashCommand, SlashCommandOutput, SlashCommandRegistry};
+pub use assistant_slash_command::{SlashCommand, SlashCommandOutput};
 use editor::{CompletionProvider, Editor};
 use fuzzy::{match_strings, StringMatchCandidate};
 use gpui::{AppContext, Model, Task, ViewContext, WeakView, WindowContext};
@@ -171,8 +171,7 @@ impl SlashCommandCompletionProvider {
        let mut flag = self.cancel_flag.lock();
        flag.store(true, SeqCst);
        *flag = new_cancel_flag.clone();
-        let commands = SlashCommandRegistry::global(cx);
-        if let Some(command) = commands.command(command_name) {
+        if let Some(command) = self.slash_commands.command(command_name, cx) {
            let completions = command.complete_argument(
                arguments,
                new_cancel_flag.clone(),
--- a/crates/assistant/src/slash_command/context_server_command.rs
+++ b/crates/assistant/src/slash_command/context_server_command.rs
@@ -27,7 +27,7 @@ pub struct ContextServerSlashCommand {
 impl ContextServerSlashCommand {
    pub fn new(
        server_manager: Model<ContextServerManager>,
-        server: &Arc<dyn ContextServer>,
+        server: &Arc<ContextServer>,
        prompt: Prompt,
    ) -> Self {
        Self {
@@ -152,7 +152,7 @@ impl SlashCommand for ContextServerSlashCommand {
                if result
                    .messages
                    .iter()
-                    .any(|msg| !matches!(msg.role, context_servers::types::SamplingRole::User))
+                    .any(|msg| !matches!(msg.role, context_servers::types::Role::User))
                {
                    return Err(anyhow!(
                        "Prompt contains non-user roles, which is not supported"
@@ -164,7 +164,7 @@ impl SlashCommand for ContextServerSlashCommand {
                    .messages
                    .into_iter()
                    .filter_map(|msg| match msg.content {
-                        context_servers::types::SamplingContent::Text { text } => Some(text),
+                        context_servers::types::MessageContent::Text { text } => Some(text),
                        _ => None,
                    })
                    .collect::<Vec<String>>()
--- a/crates/assistant/src/slash_command/default_command.rs
+++ b/crates/assistant/src/slash_command/default_command.rs
@@ -69,6 +69,10 @@ impl SlashCommand for DefaultSlashCommand {
                text.push('\n');
            }

+            if !text.ends_with('\n') {
+                text.push('\n');
+            }
+
            Ok(SlashCommandOutput {
                sections: vec![SlashCommandOutputSection {
                    range: 0..text.len(),
--- a/crates/assistant/src/tools/context_server_tool.rs
+++ b/crates/assistant/src/tools/context_server_tool.rs
@@ -74,11 +74,21 @@ impl Tool for ContextServerTool {
                    );
                    let response = protocol.run_tool(tool_name, arguments).await?;

-                    let tool_result = match response.tool_result {
-                        serde_json::Value::String(s) => s,
-                        _ => serde_json::to_string(&response.tool_result)?,
-                    };
-                    Ok(tool_result)
+                    let mut result = String::new();
+                    for content in response.content {
+                        match content {
+                            types::ToolResponseContent::Text { text } => {
+                                result.push_str(&text);
+                            }
+                            types::ToolResponseContent::Image { .. } => {
+                                log::warn!("Ignoring image content from tool response");
+                            }
+                            types::ToolResponseContent::Resource { .. } => {
+                                log::warn!("Ignoring resource content from tool response");
+                            }
+                        }
+                    }
+                    Ok(result)
                }
            })
        } else {
--- a/crates/assistant_slash_command/Cargo.toml
+++ b/crates/assistant_slash_command/Cargo.toml
@@ -13,8 +13,10 @@ path = "src/assistant_slash_command.rs"

 [dependencies]
 anyhow.workspace = true
+async-trait.workspace = true
 collections.workspace = true
 derive_more.workspace = true
+extension.workspace = true
 futures.workspace = true
 gpui.workspace = true
 language.workspace = true
@@ -22,6 +24,7 @@ language_model.workspace = true
 parking_lot.workspace = true
 serde.workspace = true
 serde_json.workspace = true
+ui.workspace = true
 workspace.workspace = true

 [dev-dependencies]
--- a/crates/assistant_slash_command/src/assistant_slash_command.rs
+++ b/crates/assistant_slash_command/src/assistant_slash_command.rs
@@ -1,5 +1,8 @@
+mod extension_slash_command;
 mod slash_command_registry;

+pub use crate::extension_slash_command::*;
+pub use crate::slash_command_registry::*;
 use anyhow::Result;
 use futures::stream::{self, BoxStream};
 use futures::StreamExt;
@@ -7,7 +10,6 @@ use gpui::{AnyElement, AppContext, ElementId, SharedString, Task, WeakView, Wind
 use language::{BufferSnapshot, CodeLabel, LspAdapterDelegate, OffsetRangeExt};
 pub use language_model::Role;
 use serde::{Deserialize, Serialize};
-pub use slash_command_registry::*;
 use std::{
    ops::Range,
    sync::{atomic::AtomicBool, Arc},
--- a/crates/assistant_slash_command/src/extension_slash_command.rs
+++ b/crates/assistant_slash_command/src/extension_slash_command.rs
@@ -0,0 +1,143 @@
+use std::path::PathBuf;
+use std::sync::{atomic::AtomicBool, Arc};
+
+use anyhow::Result;
+use async_trait::async_trait;
+use extension::{Extension, WorktreeDelegate};
+use gpui::{Task, WeakView, WindowContext};
+use language::{BufferSnapshot, LspAdapterDelegate};
+use ui::prelude::*;
+use workspace::Workspace;
+
+use crate::{
+    ArgumentCompletion, SlashCommand, SlashCommandOutput, SlashCommandOutputSection,
+    SlashCommandResult,
+};
+
+/// An adapter that allows an [`LspAdapterDelegate`] to be used as a [`WorktreeDelegate`].
+struct WorktreeDelegateAdapter(Arc<dyn LspAdapterDelegate>);
+
+#[async_trait]
+impl WorktreeDelegate for WorktreeDelegateAdapter {
+    fn id(&self) -> u64 {
+        self.0.worktree_id().to_proto()
+    }
+
+    fn root_path(&self) -> String {
+        self.0.worktree_root_path().to_string_lossy().to_string()
+    }
+
+    async fn read_text_file(&self, path: PathBuf) -> Result<String> {
+        self.0.read_text_file(path).await
+    }
+
+    async fn which(&self, binary_name: String) -> Option<String> {
+        self.0
+            .which(binary_name.as_ref())
+            .await
+            .map(|path| path.to_string_lossy().to_string())
+    }
+
+    async fn shell_env(&self) -> Vec<(String, String)> {
+        self.0.shell_env().await.into_iter().collect()
+    }
+}
+
+pub struct ExtensionSlashCommand {
+    extension: Arc<dyn Extension>,
+    command: extension::SlashCommand,
+}
+
+impl ExtensionSlashCommand {
+    pub fn new(extension: Arc<dyn Extension>, command: extension::SlashCommand) -> Self {
+        Self { extension, command }
+    }
+}
+
+impl SlashCommand for ExtensionSlashCommand {
+    fn name(&self) -> String {
+        self.command.name.clone()
+    }
+
+    fn description(&self) -> String {
+        self.command.description.clone()
+    }
+
+    fn menu_text(&self) -> String {
+        self.command.tooltip_text.clone()
+    }
+
+    fn requires_argument(&self) -> bool {
+        self.command.requires_argument
+    }
+
+    fn complete_argument(
+        self: Arc<Self>,
+        arguments: &[String],
+        _cancel: Arc<AtomicBool>,
+        _workspace: Option<WeakView<Workspace>>,
+        cx: &mut WindowContext,
+    ) -> Task<Result<Vec<ArgumentCompletion>>> {
+        let command = self.command.clone();
+        let arguments = arguments.to_owned();
+        cx.background_executor().spawn(async move {
+            let completions = self
+                .extension
+                .complete_slash_command_argument(command, arguments)
+                .await?;
+
+            anyhow::Ok(
+                completions
+                    .into_iter()
+                    .map(|completion| ArgumentCompletion {
+                        label: completion.label.into(),
+                        new_text: completion.new_text,
+                        replace_previous_arguments: false,
+                        after_completion: completion.run_command.into(),
+                    })
+                    .collect(),
+            )
+        })
+    }
+
+    fn run(
+        self: Arc<Self>,
+        arguments: &[String],
+        _context_slash_command_output_sections: &[SlashCommandOutputSection<language::Anchor>],
+        _context_buffer: BufferSnapshot,
+        _workspace: WeakView<Workspace>,
+        delegate: Option<Arc<dyn LspAdapterDelegate>>,
+        cx: &mut WindowContext,
+    ) -> Task<SlashCommandResult> {
+        let command = self.command.clone();
+        let arguments = arguments.to_owned();
+        let output = cx.background_executor().spawn(async move {
+            let delegate =
+                delegate.map(|delegate| Arc::new(WorktreeDelegateAdapter(delegate.clone())) as _);
+            let output = self
+                .extension
+                .run_slash_command(command, arguments, delegate)
+                .await?;
+
+            anyhow::Ok(output)
+        });
+        cx.foreground_executor().spawn(async move {
+            let output = output.await?;
+            Ok(SlashCommandOutput {
+                text: output.text,
+                sections: output
+                    .sections
+                    .into_iter()
+                    .map(|section| SlashCommandOutputSection {
+                        range: section.range,
+                        icon: IconName::Code,
+                        label: section.label.into(),
+                        metadata: None,
+                    })
+                    .collect(),
+                run_commands_in_text: false,
+            }
+            .to_event_stream())
+        })
+    }
+}
--- a/crates/collab/Cargo.toml
+++ b/crates/collab/Cargo.toml
@@ -78,6 +78,7 @@ uuid.workspace = true

 [dev-dependencies]
 assistant = { workspace = true, features = ["test-support"] }
+context_servers.workspace = true
 async-trait.workspace = true
 audio.workspace = true
 call = { workspace = true, features = ["test-support"] }
--- a/crates/collab/src/tests/integration_tests.rs
+++ b/crates/collab/src/tests/integration_tests.rs
@@ -6486,6 +6486,8 @@ async fn test_context_collaboration_with_reconnect(
        assert_eq!(project.collaborators().len(), 1);
    });

+    cx_a.update(context_servers::init);
+    cx_b.update(context_servers::init);
    let prompt_builder = Arc::new(PromptBuilder::new(None).unwrap());
    let context_store_a = cx_a
        .update(|cx| {
--- a/crates/command_palette_hooks/src/command_palette_hooks.rs
+++ b/crates/command_palette_hooks/src/command_palette_hooks.rs
@@ -39,11 +39,13 @@ impl CommandPaletteFilter {
    }

    /// Updates the global [`CommandPaletteFilter`] using the given closure.
-    pub fn update_global<F, R>(cx: &mut AppContext, update: F) -> R
+    pub fn update_global<F>(cx: &mut AppContext, update: F)
    where
-        F: FnOnce(&mut Self, &mut AppContext) -> R,
+        F: FnOnce(&mut Self, &mut AppContext),
    {
-        cx.update_global(|this: &mut GlobalCommandPaletteFilter, cx| update(&mut this.0, cx))
+        if cx.has_global::<GlobalCommandPaletteFilter>() {
+            cx.update_global(|this: &mut GlobalCommandPaletteFilter, cx| update(&mut this.0, cx))
+        }
    }

    /// Returns whether the given [`Action`] is hidden by the filter.
--- a/crates/context_servers/Cargo.toml
+++ b/crates/context_servers/Cargo.toml
@@ -13,7 +13,6 @@ path = "src/context_servers.rs"

 [dependencies]
 anyhow.workspace = true
-async-trait.workspace = true
 collections.workspace = true
 command_palette_hooks.workspace = true
 futures.workspace = true
--- a/crates/context_servers/src/client.rs
+++ b/crates/context_servers/src/client.rs
@@ -25,6 +25,13 @@ use util::TryFutureExt;
 const JSON_RPC_VERSION: &str = "2.0";
 const REQUEST_TIMEOUT: Duration = Duration::from_secs(60);

+// Standard JSON-RPC error codes
+pub const PARSE_ERROR: i32 = -32700;
+pub const INVALID_REQUEST: i32 = -32600;
+pub const METHOD_NOT_FOUND: i32 = -32601;
+pub const INVALID_PARAMS: i32 = -32602;
+pub const INTERNAL_ERROR: i32 = -32603;
+
 type ResponseHandler = Box<dyn Send + FnOnce(Result<String, Error>)>;
 type NotificationHandler = Box<dyn Send + FnMut(Value, AsyncAppContext)>;

--- a/crates/context_servers/src/context_servers.rs
+++ b/crates/context_servers/src/context_servers.rs
@@ -8,7 +8,6 @@ use command_palette_hooks::CommandPaletteFilter;
 use gpui::{actions, AppContext};
 use settings::Settings;

-pub use crate::manager::ContextServer;
 use crate::manager::ContextServerSettings;
 pub use crate::registry::ContextServerFactoryRegistry;

--- a/crates/context_servers/src/manager.rs
+++ b/crates/context_servers/src/manager.rs
@@ -15,23 +15,23 @@
 //! and react to changes in settings.

 use std::path::Path;
-use std::pin::Pin;
 use std::sync::Arc;

 use anyhow::{bail, Result};
-use async_trait::async_trait;
-use collections::{HashMap, HashSet};
-use futures::{Future, FutureExt};
-use gpui::{AsyncAppContext, EventEmitter, ModelContext, Task};
+use collections::HashMap;
+use command_palette_hooks::CommandPaletteFilter;
+use gpui::{AsyncAppContext, EventEmitter, Model, ModelContext, Subscription, Task, WeakModel};
 use log;
 use parking_lot::RwLock;
+use project::Project;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
-use settings::{Settings, SettingsSources};
+use settings::{Settings, SettingsSources, SettingsStore};
+use util::ResultExt as _;

 use crate::{
    client::{self, Client},
-    types,
+    types, ContextServerFactoryRegistry, CONTEXT_SERVERS_NAMESPACE,
 };

 #[derive(Deserialize, Serialize, Default, Clone, PartialEq, Eq, JsonSchema, Debug)]
@@ -66,25 +66,13 @@ impl Settings for ContextServerSettings {
    }
 }

-#[async_trait(?Send)]
-pub trait ContextServer: Send + Sync + 'static {
-    fn id(&self) -> Arc<str>;
-    fn config(&self) -> Arc<ServerConfig>;
-    fn client(&self) -> Option<Arc<crate::protocol::InitializedContextServerProtocol>>;
-    fn start<'a>(
-        self: Arc<Self>,
-        cx: &'a AsyncAppContext,
-    ) -> Pin<Box<dyn 'a + Future<Output = Result<()>>>>;
-    fn stop(&self) -> Result<()>;
-}
-
-pub struct NativeContextServer {
+pub struct ContextServer {
    pub id: Arc<str>,
    pub config: Arc<ServerConfig>,
    pub client: RwLock<Option<Arc<crate::protocol::InitializedContextServerProtocol>>>,
 }

-impl NativeContextServer {
+impl ContextServer {
    pub fn new(id: Arc<str>, config: Arc<ServerConfig>) -> Self {
        Self {
            id,
@@ -92,61 +80,52 @@ impl NativeContextServer {
            client: RwLock::new(None),
        }
    }
-}

-#[async_trait(?Send)]
-impl ContextServer for NativeContextServer {
-    fn id(&self) -> Arc<str> {
+    pub fn id(&self) -> Arc<str> {
        self.id.clone()
    }

-    fn config(&self) -> Arc<ServerConfig> {
+    pub fn config(&self) -> Arc<ServerConfig> {
        self.config.clone()
    }

-    fn client(&self) -> Option<Arc<crate::protocol::InitializedContextServerProtocol>> {
+    pub fn client(&self) -> Option<Arc<crate::protocol::InitializedContextServerProtocol>> {
        self.client.read().clone()
    }

-    fn start<'a>(
-        self: Arc<Self>,
-        cx: &'a AsyncAppContext,
-    ) -> Pin<Box<dyn 'a + Future<Output = Result<()>>>> {
-        async move {
-            log::info!("starting context server {}", self.id);
-            let Some(command) = &self.config.command else {
-                bail!("no command specified for server {}", self.id);
-            };
-            let client = Client::new(
-                client::ContextServerId(self.id.clone()),
-                client::ModelContextServerBinary {
-                    executable: Path::new(&command.path).to_path_buf(),
-                    args: command.args.clone(),
-                    env: command.env.clone(),
-                },
-                cx.clone(),
-            )?;
+    pub async fn start(self: Arc<Self>, cx: &AsyncAppContext) -> Result<()> {
+        log::info!("starting context server {}", self.id);
+        let Some(command) = &self.config.command else {
+            bail!("no command specified for server {}", self.id);
+        };
+        let client = Client::new(
+            client::ContextServerId(self.id.clone()),
+            client::ModelContextServerBinary {
+                executable: Path::new(&command.path).to_path_buf(),
+                args: command.args.clone(),
+                env: command.env.clone(),
+            },
+            cx.clone(),
+        )?;

-            let protocol = crate::protocol::ModelContextProtocol::new(client);
-            let client_info = types::Implementation {
-                name: "Zed".to_string(),
-                version: env!("CARGO_PKG_VERSION").to_string(),
-            };
-            let initialized_protocol = protocol.initialize(client_info).await?;
+        let protocol = crate::protocol::ModelContextProtocol::new(client);
+        let client_info = types::Implementation {
+            name: "Zed".to_string(),
+            version: env!("CARGO_PKG_VERSION").to_string(),
+        };
+        let initialized_protocol = protocol.initialize(client_info).await?;

-            log::debug!(
-                "context server {} initialized: {:?}",
-                self.id,
-                initialized_protocol.initialize,
-            );
+        log::debug!(
+            "context server {} initialized: {:?}",
+            self.id,
+            initialized_protocol.initialize,
+        );

-            *self.client.write() = Some(Arc::new(initialized_protocol));
-            Ok(())
-        }
-        .boxed_local()
+        *self.client.write() = Some(Arc::new(initialized_protocol));
+        Ok(())
    }

-    fn stop(&self) -> Result<()> {
+    pub fn stop(&self) -> Result<()> {
        let mut client = self.client.write();
        if let Some(protocol) = client.take() {
            drop(protocol);
@@ -155,13 +134,13 @@ impl ContextServer for NativeContextServer {
    }
 }

-/// A Context server manager manages the starting and stopping
-/// of all servers. To obtain a server to interact with, a crate
-/// must go through the `GlobalContextServerManager` which holds
-/// a model to the ContextServerManager.
 pub struct ContextServerManager {
-    servers: HashMap<Arc<str>, Arc<dyn ContextServer>>,
-    pending_servers: HashSet<Arc<str>>,
+    servers: HashMap<Arc<str>, Arc<ContextServer>>,
+    project: Model<Project>,
+    registry: Model<ContextServerFactoryRegistry>,
+    update_servers_task: Option<Task<Result<()>>>,
+    needs_server_update: bool,
+    _subscriptions: Vec<Subscription>,
 }

 pub enum Event {
@@ -171,74 +150,66 @@ pub enum Event {

 impl EventEmitter<Event> for ContextServerManager {}

-impl Default for ContextServerManager {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
 impl ContextServerManager {
-    pub fn new() -> Self {
-        Self {
+    pub fn new(
+        registry: Model<ContextServerFactoryRegistry>,
+        project: Model<Project>,
+        cx: &mut ModelContext<Self>,
+    ) -> Self {
+        let mut this = Self {
+            _subscriptions: vec![
+                cx.observe(&registry, |this, _registry, cx| {
+                    this.available_context_servers_changed(cx);
+                }),
+                cx.observe_global::<SettingsStore>(|this, cx| {
+                    this.available_context_servers_changed(cx);
+                }),
+            ],
+            project,
+            registry,
+            needs_server_update: false,
            servers: HashMap::default(),
-            pending_servers: HashSet::default(),
-        }
-    }
-
-    pub fn add_server(
-        &mut self,
-        server: Arc<dyn ContextServer>,
-        cx: &ModelContext<Self>,
-    ) -> Task<anyhow::Result<()>> {
-        let server_id = server.id();
-
-        if self.servers.contains_key(&server_id) || self.pending_servers.contains(&server_id) {
-            return Task::ready(Ok(()));
-        }
-
-        let task = {
-            let server_id = server_id.clone();
-            cx.spawn(|this, mut cx| async move {
-                server.clone().start(&cx).await?;
-                this.update(&mut cx, |this, cx| {
-                    this.servers.insert(server_id.clone(), server);
-                    this.pending_servers.remove(&server_id);
-                    cx.emit(Event::ServerStarted {
-                        server_id: server_id.clone(),
-                    });
-                })?;
-                Ok(())
-            })
+            update_servers_task: None,
        };
-
-        self.pending_servers.insert(server_id);
-        task
+        this.available_context_servers_changed(cx);
+        this
    }

-    pub fn get_server(&self, id: &str) -> Option<Arc<dyn ContextServer>> {
-        self.servers.get(id).cloned()
+    fn available_context_servers_changed(&mut self, cx: &mut ModelContext<Self>) {
+        if self.update_servers_task.is_some() {
+            self.needs_server_update = true;
+        } else {
+            self.update_servers_task = Some(cx.spawn(|this, mut cx| async move {
+                this.update(&mut cx, |this, _| {
+                    this.needs_server_update = false;
+                })?;
+
+                Self::maintain_servers(this.clone(), cx.clone()).await?;
+
+                this.update(&mut cx, |this, cx| {
+                    let has_any_context_servers = !this.servers().is_empty();
+                    if has_any_context_servers {
+                        CommandPaletteFilter::update_global(cx, |filter, _cx| {
+                            filter.show_namespace(CONTEXT_SERVERS_NAMESPACE);
+                        });
+                    }
+
+                    this.update_servers_task.take();
+                    if this.needs_server_update {
+                        this.available_context_servers_changed(cx);
+                    }
+                })?;
+
+                Ok(())
+            }));
+        }
    }

-    pub fn remove_server(
-        &mut self,
-        id: &Arc<str>,
-        cx: &ModelContext<Self>,
-    ) -> Task<anyhow::Result<()>> {
-        let id = id.clone();
-        cx.spawn(|this, mut cx| async move {
-            if let Some(server) =
-                this.update(&mut cx, |this, _cx| this.servers.remove(id.as_ref()))?
-            {
-                server.stop()?;
-            }
-            this.update(&mut cx, |this, cx| {
-                this.pending_servers.remove(id.as_ref());
-                cx.emit(Event::ServerStopped {
-                    server_id: id.clone(),
-                })
-            })?;
-            Ok(())
-        })
+    pub fn get_server(&self, id: &str) -> Option<Arc<ContextServer>> {
+        self.servers
+            .get(id)
+            .filter(|server| server.client().is_some())
+            .cloned()
    }

    pub fn restart_server(
@@ -251,7 +222,7 @@ impl ContextServerManager {
            if let Some(server) = this.update(&mut cx, |this, _cx| this.servers.remove(&id))? {
                server.stop()?;
                let config = server.config();
-                let new_server = Arc::new(NativeContextServer::new(id.clone(), config));
+                let new_server = Arc::new(ContextServer::new(id.clone(), config));
                new_server.clone().start(&cx).await?;
                this.update(&mut cx, |this, cx| {
                    this.servers.insert(id.clone(), new_server);
@@ -267,45 +238,83 @@ impl ContextServerManager {
        })
    }

-    pub fn servers(&self) -> Vec<Arc<dyn ContextServer>> {
-        self.servers.values().cloned().collect()
+    pub fn servers(&self) -> Vec<Arc<ContextServer>> {
+        self.servers
+            .values()
+            .filter(|server| server.client().is_some())
+            .cloned()
+            .collect()
    }

-    pub fn maintain_servers(&mut self, settings: &ContextServerSettings, cx: &ModelContext<Self>) {
-        let current_servers = self
-            .servers()
-            .into_iter()
-            .map(|server| (server.id(), server.config()))
-            .collect::<HashMap<_, _>>();
+    async fn maintain_servers(this: WeakModel<Self>, mut cx: AsyncAppContext) -> Result<()> {
+        let mut desired_servers = HashMap::default();

-        let new_servers = settings
-            .context_servers
-            .iter()
-            .map(|(id, config)| (id.clone(), config.clone()))
-            .collect::<HashMap<_, _>>();
+        let (registry, project) = this.update(&mut cx, |this, cx| {
+            let location = this.project.read(cx).worktrees(cx).next().map(|worktree| {
+                settings::SettingsLocation {
+                    worktree_id: worktree.read(cx).id(),
+                    path: Path::new(""),
+                }
+            });
+            let settings = ContextServerSettings::get(location, cx);
+            desired_servers = settings.context_servers.clone();

-        let servers_to_add = new_servers
-            .iter()
-            .filter(|(id, _)| !current_servers.contains_key(id.as_ref()))
-            .map(|(id, config)| (id.clone(), config.clone()))
-            .collect::<Vec<_>>();
+            (this.registry.clone(), this.project.clone())
+        })?;

-        let servers_to_remove = current_servers
-            .keys()
-            .filter(|id| !new_servers.contains_key(id.as_ref()))
-            .cloned()
-            .collect::<Vec<_>>();
-
-        log::trace!("servers_to_add={:?}", servers_to_add);
-        for (id, config) in servers_to_add {
-            if config.command.is_some() {
-                let server = Arc::new(NativeContextServer::new(id, Arc::new(config)));
-                self.add_server(server, cx).detach_and_log_err(cx);
+        for (id, factory) in
+            registry.read_with(&cx, |registry, _| registry.context_server_factories())?
+        {
+            let config = desired_servers.entry(id).or_default();
+            if config.command.is_none() {
+                if let Some(extension_command) = factory(project.clone(), &cx).await.log_err() {
+                    config.command = Some(extension_command);
+                }
            }
        }

-        for id in servers_to_remove {
-            self.remove_server(&id, cx).detach_and_log_err(cx);
+        let mut servers_to_start = HashMap::default();
+        let mut servers_to_stop = HashMap::default();
+
+        this.update(&mut cx, |this, _cx| {
+            this.servers.retain(|id, server| {
+                if desired_servers.contains_key(id) {
+                    true
+                } else {
+                    servers_to_stop.insert(id.clone(), server.clone());
+                    false
+                }
+            });
+
+            for (id, config) in desired_servers {
+                let existing_config = this.servers.get(&id).map(|server| server.config());
+                if existing_config.as_deref() != Some(&config) {
+                    let config = Arc::new(config);
+                    let server = Arc::new(ContextServer::new(id.clone(), config));
+                    servers_to_start.insert(id.clone(), server.clone());
+                    let old_server = this.servers.insert(id.clone(), server);
+                    if let Some(old_server) = old_server {
+                        servers_to_stop.insert(id, old_server);
+                    }
+                }
+            }
+        })?;
+
+        for (id, server) in servers_to_stop {
+            server.stop().log_err();
+            this.update(&mut cx, |_, cx| {
+                cx.emit(Event::ServerStopped { server_id: id })
+            })?;
        }
+
+        for (id, server) in servers_to_start {
+            if server.start(&cx).await.log_err().is_some() {
+                this.update(&mut cx, |_, cx| {
+                    cx.emit(Event::ServerStarted { server_id: id })
+                })?;
+            }
+        }
+
+        Ok(())
    }
 }
--- a/crates/context_servers/src/protocol.rs
+++ b/crates/context_servers/src/protocol.rs
@@ -11,8 +11,6 @@ use collections::HashMap;
 use crate::client::Client;
 use crate::types;

-const PROTOCOL_VERSION: &str = "2024-10-07";
-
 pub struct ModelContextProtocol {
    inner: Client,
 }
@@ -23,10 +21,9 @@ impl ModelContextProtocol {
    }

    fn supported_protocols() -> Vec<types::ProtocolVersion> {
-        vec![
-            types::ProtocolVersion::VersionString(PROTOCOL_VERSION.to_string()),
-            types::ProtocolVersion::VersionNumber(1),
-        ]
+        vec![types::ProtocolVersion(
+            types::LATEST_PROTOCOL_VERSION.to_string(),
+        )]
    }

    pub async fn initialize(
@@ -34,11 +31,13 @@ impl ModelContextProtocol {
        client_info: types::Implementation,
    ) -> Result<InitializedContextServerProtocol> {
        let params = types::InitializeParams {
-            protocol_version: types::ProtocolVersion::VersionString(PROTOCOL_VERSION.to_string()),
+            protocol_version: types::ProtocolVersion(types::LATEST_PROTOCOL_VERSION.to_string()),
            capabilities: types::ClientCapabilities {
                experimental: None,
                sampling: None,
+                roots: None,
            },
+            meta: None,
            client_info,
        };

@@ -148,6 +147,7 @@ impl InitializedContextServerProtocol {
        let params = types::PromptsGetParams {
            name: prompt.as_ref().to_string(),
            arguments: Some(arguments),
+            meta: None,
        };

        let response: types::PromptsGetResponse = self
@@ -170,6 +170,7 @@ impl InitializedContextServerProtocol {
                name: argument.into(),
                value: value.into(),
            },
+            meta: None,
        };
        let result: types::CompletionCompleteResponse = self
            .inner
@@ -210,6 +211,7 @@ impl InitializedContextServerProtocol {
        let params = types::CallToolParams {
            name: tool.as_ref().to_string(),
            arguments,
+            meta: None,
        };

        let response: types::CallToolResponse = self
--- a/crates/context_servers/src/registry.rs
+++ b/crates/context_servers/src/registry.rs
@@ -2,75 +2,61 @@ use std::sync::Arc;

 use anyhow::Result;
 use collections::HashMap;
-use gpui::{AppContext, AsyncAppContext, Global, Model, ReadGlobal, Task};
-use parking_lot::RwLock;
+use gpui::{AppContext, AsyncAppContext, Context, Global, Model, ReadGlobal, Task};
 use project::Project;

-use crate::ContextServer;
+use crate::manager::ServerCommand;

 pub type ContextServerFactory = Arc<
-    dyn Fn(Model<Project>, &AsyncAppContext) -> Task<Result<Arc<dyn ContextServer>>>
-        + Send
-        + Sync
-        + 'static,
+    dyn Fn(Model<Project>, &AsyncAppContext) -> Task<Result<ServerCommand>> + Send + Sync + 'static,
 >;

-#[derive(Default)]
-struct GlobalContextServerFactoryRegistry(Arc<ContextServerFactoryRegistry>);
+struct GlobalContextServerFactoryRegistry(Model<ContextServerFactoryRegistry>);

 impl Global for GlobalContextServerFactoryRegistry {}

-#[derive(Default)]
-struct ContextServerFactoryRegistryState {
-    context_servers: HashMap<Arc<str>, ContextServerFactory>,
-}
-
 #[derive(Default)]
 pub struct ContextServerFactoryRegistry {
-    state: RwLock<ContextServerFactoryRegistryState>,
+    context_servers: HashMap<Arc<str>, ContextServerFactory>,
 }

 impl ContextServerFactoryRegistry {
    /// Returns the global [`ContextServerFactoryRegistry`].
-    pub fn global(cx: &AppContext) -> Arc<Self> {
+    pub fn global(cx: &AppContext) -> Model<Self> {
        GlobalContextServerFactoryRegistry::global(cx).0.clone()
    }

    /// Returns the global [`ContextServerFactoryRegistry`].
    ///
    /// Inserts a default [`ContextServerFactoryRegistry`] if one does not yet exist.
-    pub fn default_global(cx: &mut AppContext) -> Arc<Self> {
-        cx.default_global::<GlobalContextServerFactoryRegistry>()
-            .0
-            .clone()
+    pub fn default_global(cx: &mut AppContext) -> Model<Self> {
+        if !cx.has_global::<GlobalContextServerFactoryRegistry>() {
+            let registry = cx.new_model(|_| Self::new());
+            cx.set_global(GlobalContextServerFactoryRegistry(registry));
+        }
+        cx.global::<GlobalContextServerFactoryRegistry>().0.clone()
    }

-    pub fn new() -> Arc<Self> {
-        Arc::new(Self {
-            state: RwLock::new(ContextServerFactoryRegistryState {
-                context_servers: HashMap::default(),
-            }),
-        })
+    pub fn new() -> Self {
+        Self {
+            context_servers: HashMap::default(),
+        }
    }

    pub fn context_server_factories(&self) -> Vec<(Arc<str>, ContextServerFactory)> {
-        self.state
-            .read()
-            .context_servers
+        self.context_servers
            .iter()
            .map(|(id, factory)| (id.clone(), factory.clone()))
            .collect()
    }

    /// Registers the provided [`ContextServerFactory`].
-    pub fn register_server_factory(&self, id: Arc<str>, factory: ContextServerFactory) {
-        let mut state = self.state.write();
-        state.context_servers.insert(id, factory);
+    pub fn register_server_factory(&mut self, id: Arc<str>, factory: ContextServerFactory) {
+        self.context_servers.insert(id, factory);
    }

    /// Unregisters the [`ContextServerFactory`] for the server with the given ID.
-    pub fn unregister_server_factory_by_id(&self, server_id: &str) {
-        let mut state = self.state.write();
-        state.context_servers.remove(server_id);
+    pub fn unregister_server_factory_by_id(&mut self, server_id: &str) {
+        self.context_servers.remove(server_id);
    }
 }
--- a/crates/context_servers/src/types.rs
+++ b/crates/context_servers/src/types.rs
@@ -2,8 +2,8 @@ use collections::HashMap;
 use serde::{Deserialize, Serialize};
 use url::Url;

-#[derive(Debug, Serialize)]
-#[serde(rename_all = "camelCase")]
+pub const LATEST_PROTOCOL_VERSION: &str = "2024-11-05";
+
 pub enum RequestType {
    Initialize,
    CallTool,
@@ -18,6 +18,7 @@ pub enum RequestType {
    Ping,
    ListTools,
    ListResourceTemplates,
+    ListRoots,
 }

 impl RequestType {
@@ -36,16 +37,14 @@ impl RequestType {
            RequestType::Ping => "ping",
            RequestType::ListTools => "tools/list",
            RequestType::ListResourceTemplates => "resources/templates/list",
+            RequestType::ListRoots => "roots/list",
        }
    }
 }

 #[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(untagged)]
-pub enum ProtocolVersion {
-    VersionString(String),
-    VersionNumber(u32),
-}
+#[serde(transparent)]
+pub struct ProtocolVersion(pub String);

 #[derive(Debug, Serialize)]
 #[serde(rename_all = "camelCase")]
@@ -53,6 +52,8 @@ pub struct InitializeParams {
    pub protocol_version: ProtocolVersion,
    pub capabilities: ClientCapabilities,
    pub client_info: Implementation,
+    #[serde(rename = "_meta", skip_serializing_if = "Option::is_none")]
+    pub meta: Option<HashMap<String, serde_json::Value>>,
 }

 #[derive(Debug, Serialize)]
@@ -61,30 +62,40 @@ pub struct CallToolParams {
    pub name: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub arguments: Option<HashMap<String, serde_json::Value>>,
+    #[serde(rename = "_meta", skip_serializing_if = "Option::is_none")]
+    pub meta: Option<HashMap<String, serde_json::Value>>,
 }

 #[derive(Debug, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ResourcesUnsubscribeParams {
    pub uri: Url,
+    #[serde(rename = "_meta", skip_serializing_if = "Option::is_none")]
+    pub meta: Option<HashMap<String, serde_json::Value>>,
 }

 #[derive(Debug, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ResourcesSubscribeParams {
    pub uri: Url,
+    #[serde(rename = "_meta", skip_serializing_if = "Option::is_none")]
+    pub meta: Option<HashMap<String, serde_json::Value>>,
 }

 #[derive(Debug, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ResourcesReadParams {
    pub uri: Url,
+    #[serde(rename = "_meta", skip_serializing_if = "Option::is_none")]
+    pub meta: Option<HashMap<String, serde_json::Value>>,
 }

 #[derive(Debug, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct LoggingSetLevelParams {
    pub level: LoggingLevel,
+    #[serde(rename = "_meta", skip_serializing_if = "Option::is_none")]
+    pub meta: Option<HashMap<String, serde_json::Value>>,
 }

 #[derive(Debug, Serialize)]
@@ -93,6 +104,8 @@ pub struct PromptsGetParams {
    pub name: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub arguments: Option<HashMap<String, String>>,
+    #[serde(rename = "_meta", skip_serializing_if = "Option::is_none")]
+    pub meta: Option<HashMap<String, serde_json::Value>>,
 }

 #[derive(Debug, Serialize)]
@@ -100,6 +113,8 @@ pub struct PromptsGetParams {
 pub struct CompletionCompleteParams {
    pub r#ref: CompletionReference,
    pub argument: CompletionArgument,
+    #[serde(rename = "_meta", skip_serializing_if = "Option::is_none")]
+    pub meta: Option<HashMap<String, serde_json::Value>>,
 }

 #[derive(Debug, Serialize)]
@@ -145,12 +160,16 @@ pub struct InitializeResponse {
    pub protocol_version: ProtocolVersion,
    pub capabilities: ServerCapabilities,
    pub server_info: Implementation,
+    #[serde(rename = "_meta", skip_serializing_if = "Option::is_none")]
+    pub meta: Option<HashMap<String, serde_json::Value>>,
 }

 #[derive(Debug, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ResourcesReadResponse {
-    pub contents: Vec<ResourceContent>,
+    pub contents: Vec<ResourceContents>,
+    #[serde(rename = "_meta", skip_serializing_if = "Option::is_none")]
+    pub meta: Option<HashMap<String, serde_json::Value>>,
 }

 #[derive(Debug, Deserialize)]
@@ -159,29 +178,39 @@ pub struct ResourcesListResponse {
    pub resources: Vec<Resource>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_cursor: Option<String>,
+    #[serde(rename = "_meta", skip_serializing_if = "Option::is_none")]
+    pub meta: Option<HashMap<String, serde_json::Value>>,
+}
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SamplingMessage {
+    pub role: Role,
+    pub content: MessageContent,
 }

 #[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
-pub struct SamplingMessage {
-    pub role: SamplingRole,
-    pub content: SamplingContent,
+pub struct PromptMessage {
+    pub role: Role,
+    pub content: MessageContent,
 }

 #[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "lowercase")]
-pub enum SamplingRole {
+pub enum Role {
    User,
    Assistant,
 }

 #[derive(Debug, Serialize, Deserialize)]
 #[serde(tag = "type")]
-pub enum SamplingContent {
+pub enum MessageContent {
    #[serde(rename = "text")]
    Text { text: String },
    #[serde(rename = "image")]
    Image { data: String, mime_type: String },
+    #[serde(rename = "resource")]
+    Resource { resource: ResourceContents },
 }

 #[derive(Debug, Deserialize)]
@@ -189,7 +218,9 @@ pub enum SamplingContent {
 pub struct PromptsGetResponse {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
-    pub messages: Vec<SamplingMessage>,
+    pub messages: Vec<PromptMessage>,
+    #[serde(rename = "_meta", skip_serializing_if = "Option::is_none")]
+    pub meta: Option<HashMap<String, serde_json::Value>>,
 }

 #[derive(Debug, Deserialize)]
@@ -198,12 +229,16 @@ pub struct PromptsListResponse {
    pub prompts: Vec<Prompt>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_cursor: Option<String>,
+    #[serde(rename = "_meta", skip_serializing_if = "Option::is_none")]
+    pub meta: Option<HashMap<String, serde_json::Value>>,
 }

 #[derive(Debug, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct CompletionCompleteResponse {
    pub completion: CompletionResult,
+    #[serde(rename = "_meta", skip_serializing_if = "Option::is_none")]
+    pub meta: Option<HashMap<String, serde_json::Value>>,
 }

 #[derive(Debug, Deserialize)]
@@ -214,6 +249,8 @@ pub struct CompletionResult {
    pub total: Option<u32>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub has_more: Option<bool>,
+    #[serde(rename = "_meta", skip_serializing_if = "Option::is_none")]
+    pub meta: Option<HashMap<String, serde_json::Value>>,
 }

 #[derive(Debug, Deserialize, Serialize)]
@@ -243,6 +280,8 @@ pub struct ClientCapabilities {
    pub experimental: Option<HashMap<String, serde_json::Value>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sampling: Option<serde_json::Value>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub roots: Option<RootsCapabilities>,
 }

 #[derive(Debug, Serialize, Deserialize)]
@@ -283,6 +322,13 @@ pub struct ToolsCapabilities {
    pub list_changed: Option<bool>,
 }

+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RootsCapabilities {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub list_changed: Option<bool>,
+}
+
 #[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct Tool {
@@ -312,14 +358,28 @@ pub struct Resource {

 #[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
-pub struct ResourceContent {
+pub struct ResourceContents {
    pub uri: Url,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub mime_type: Option<String>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TextResourceContents {
+    pub uri: Url,
    #[serde(skip_serializing_if = "Option::is_none")]
-    pub text: Option<String>,
+    pub mime_type: Option<String>,
+    pub text: String,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BlobResourceContents {
+    pub uri: Url,
    #[serde(skip_serializing_if = "Option::is_none")]
-    pub blob: Option<String>,
+    pub mime_type: Option<String>,
+    pub blob: String,
 }

 #[derive(Debug, Serialize, Deserialize)]
@@ -338,8 +398,32 @@ pub struct ResourceTemplate {
 pub enum LoggingLevel {
    Debug,
    Info,
+    Notice,
    Warning,
    Error,
+    Critical,
+    Alert,
+    Emergency,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ModelPreferences {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub hints: Option<Vec<ModelHint>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub cost_priority: Option<f64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub speed_priority: Option<f64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub intelligence_priority: Option<f64>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ModelHint {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
 }

 #[derive(Debug, Serialize)]
@@ -352,6 +436,7 @@ pub enum NotificationType {
    ResourcesListChanged,
    ToolsListChanged,
    PromptsListChanged,
+    RootsListChanged,
 }

 impl NotificationType {
@@ -364,6 +449,7 @@ impl NotificationType {
            NotificationType::ResourcesListChanged => "notifications/resources/list_changed",
            NotificationType::ToolsListChanged => "notifications/tools/list_changed",
            NotificationType::PromptsListChanged => "notifications/prompts/list_changed",
+            NotificationType::RootsListChanged => "notifications/roots/list_changed",
        }
    }
 }
@@ -373,6 +459,14 @@ impl NotificationType {
 pub enum ClientNotification {
    Initialized,
    Progress(ProgressParams),
+    RootsListChanged,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum ProgressToken {
+    String(String),
+    Number(f64),
 }

 #[derive(Debug, Serialize)]
@@ -382,10 +476,10 @@ pub struct ProgressParams {
    pub progress: f64,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub total: Option<f64>,
+    #[serde(rename = "_meta", skip_serializing_if = "Option::is_none")]
+    pub meta: Option<HashMap<String, serde_json::Value>>,
 }

-pub type ProgressToken = String;
-
 pub enum CompletionTotal {
    Exact(u32),
    HasMore,
@@ -410,7 +504,22 @@ pub struct Completion {
 #[derive(Debug, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct CallToolResponse {
-    pub tool_result: serde_json::Value,
+    pub content: Vec<ToolResponseContent>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub is_error: Option<bool>,
+    #[serde(rename = "_meta", skip_serializing_if = "Option::is_none")]
+    pub meta: Option<HashMap<String, serde_json::Value>>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(tag = "type")]
+pub enum ToolResponseContent {
+    #[serde(rename = "text")]
+    Text { text: String },
+    #[serde(rename = "image")]
+    Image { data: String, mime_type: String },
+    #[serde(rename = "resource")]
+    Resource { resource: ResourceContents },
 }

 #[derive(Debug, Deserialize)]
@@ -419,4 +528,22 @@ pub struct ListToolsResponse {
    pub tools: Vec<Tool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_cursor: Option<String>,
+    #[serde(rename = "_meta", skip_serializing_if = "Option::is_none")]
+    pub meta: Option<HashMap<String, serde_json::Value>>,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ListRootsResponse {
+    pub roots: Vec<Root>,
+    #[serde(rename = "_meta", skip_serializing_if = "Option::is_none")]
+    pub meta: Option<HashMap<String, serde_json::Value>>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Root {
+    pub uri: Url,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
 }
--- a/crates/editor/src/editor_settings.rs
+++ b/crates/editor/src/editor_settings.rs
@@ -279,7 +279,7 @@ pub struct EditorSettingsContent {

    /// Whether to show the signature help pop-up after completions or bracket pairs inserted.
    ///
-    /// Default: true
+    /// Default: false
    pub show_signature_help_after_edits: Option<bool>,

    /// Jupyter REPL settings.
--- a/crates/extension/src/extension.rs
+++ b/crates/extension/src/extension.rs
@@ -1,7 +1,8 @@
 pub mod extension_builder;
 mod extension_manifest;
+mod slash_command;

-use std::path::Path;
+use std::path::{Path, PathBuf};
 use std::sync::Arc;

 use anyhow::{anyhow, bail, Context as _, Result};
@@ -10,6 +11,16 @@ use gpui::Task;
 use semantic_version::SemanticVersion;

 pub use crate::extension_manifest::*;
+pub use crate::slash_command::*;
+
+#[async_trait]
+pub trait WorktreeDelegate: Send + Sync + 'static {
+    fn id(&self) -> u64;
+    fn root_path(&self) -> String;
+    async fn read_text_file(&self, path: PathBuf) -> Result<String>;
+    async fn which(&self, binary_name: String) -> Option<String>;
+    async fn shell_env(&self) -> Vec<(String, String)>;
+}

 pub trait KeyValueStoreDelegate: Send + Sync + 'static {
    fn insert(&self, key: String, docs: String) -> Task<Result<()>>;
@@ -23,6 +34,19 @@ pub trait Extension: Send + Sync + 'static {
    /// Returns the path to this extension's working directory.
    fn work_dir(&self) -> Arc<Path>;

+    async fn complete_slash_command_argument(
+        &self,
+        command: SlashCommand,
+        arguments: Vec<String>,
+    ) -> Result<Vec<SlashCommandArgumentCompletion>>;
+
+    async fn run_slash_command(
+        &self,
+        command: SlashCommand,
+        arguments: Vec<String>,
+        resource: Option<Arc<dyn WorktreeDelegate>>,
+    ) -> Result<SlashCommandOutput>;
+
    async fn suggest_docs_packages(&self, provider: Arc<str>) -> Result<Vec<String>>;

    async fn index_docs(
--- a/crates/extension/src/slash_command.rs
+++ b/crates/extension/src/slash_command.rs
@@ -0,0 +1,43 @@
+use std::ops::Range;
+
+/// A slash command for use in the Assistant.
+#[derive(Debug, Clone)]
+pub struct SlashCommand {
+    /// The name of the slash command.
+    pub name: String,
+    /// The description of the slash command.
+    pub description: String,
+    /// The tooltip text to display for the run button.
+    pub tooltip_text: String,
+    /// Whether this slash command requires an argument.
+    pub requires_argument: bool,
+}
+
+/// The output of a slash command.
+#[derive(Debug, Clone)]
+pub struct SlashCommandOutput {
+    /// The text produced by the slash command.
+    pub text: String,
+    /// The list of sections to show in the slash command placeholder.
+    pub sections: Vec<SlashCommandOutputSection>,
+}
+
+/// A section in the slash command output.
+#[derive(Debug, Clone)]
+pub struct SlashCommandOutputSection {
+    /// The range this section occupies.
+    pub range: Range<usize>,
+    /// The label to display in the placeholder for this section.
+    pub label: String,
+}
+
+/// A completion for a slash command argument.
+#[derive(Debug, Clone)]
+pub struct SlashCommandArgumentCompletion {
+    /// The label to display for this completion.
+    pub label: String,
+    /// The new text that should be inserted into the command when this completion is accepted.
+    pub new_text: String,
+    /// Whether the command should be run when accepting this completion.
+    pub run_command: bool,
+}
--- a/crates/extension_api/Cargo.toml
+++ b/crates/extension_api/Cargo.toml
@@ -8,9 +8,6 @@ keywords = ["zed", "extension"]
 edition = "2021"
 license = "Apache-2.0"

-# Remove when we're ready to publish v0.2.0.
-publish = false
-
 [lints]
 workspace = true

--- a/crates/extension_api/README.md
+++ b/crates/extension_api/README.md
@@ -63,6 +63,7 @@ Here is the compatibility of the `zed_extension_api` with versions of Zed:

 | Zed version | `zed_extension_api` version |
 | ----------- | --------------------------- |
+| `0.162.x`   | `0.0.1` - `0.2.0`           |
 | `0.149.x`   | `0.0.1` - `0.1.0`           |
 | `0.131.x`   | `0.0.1` - `0.0.6`           |
 | `0.130.x`   | `0.0.1` - `0.0.5`           |
--- a/crates/extension_host/Cargo.toml
+++ b/crates/extension_host/Cargo.toml
@@ -58,3 +58,4 @@ language = { workspace = true, features = ["test-support"] }
 parking_lot.workspace = true
 project = { workspace = true, features = ["test-support"] }
 reqwest_client.workspace = true
+theme = { workspace = true, features = ["test-support"] }
--- a/crates/extension_host/src/extension_host.rs
+++ b/crates/extension_host/src/extension_host.rs
@@ -2,6 +2,9 @@ pub mod extension_lsp_adapter;
 pub mod extension_settings;
 pub mod wasm_host;

+#[cfg(test)]
+mod extension_store_test;
+
 use crate::{extension_lsp_adapter::ExtensionLspAdapter, wasm_host::wit};
 use anyhow::{anyhow, bail, Context as _, Result};
 use async_compression::futures::bufread::GzipDecoder;
@@ -132,9 +135,8 @@ pub trait ExtensionRegistrationHooks: Send + Sync + 'static {

    fn register_slash_command(
        &self,
-        _slash_command: wit::SlashCommand,
-        _extension: WasmExtension,
-        _host: Arc<WasmHost>,
+        _extension: Arc<dyn Extension>,
+        _command: extension::SlashCommand,
    ) {
    }

@@ -142,7 +144,7 @@ pub trait ExtensionRegistrationHooks: Send + Sync + 'static {
        &self,
        _id: Arc<str>,
        _extension: WasmExtension,
-        _host: Arc<WasmHost>,
+        _cx: &mut AppContext,
    ) {
    }

@@ -1250,7 +1252,8 @@ impl ExtensionStore {

                    for (slash_command_name, slash_command) in &manifest.slash_commands {
                        this.registration_hooks.register_slash_command(
-                            crate::wit::SlashCommand {
+                            extension.clone(),
+                            extension::SlashCommand {
                                name: slash_command_name.to_string(),
                                description: slash_command.description.to_string(),
                                // We don't currently expose this as a configurable option, as it currently drives
@@ -1259,8 +1262,6 @@ impl ExtensionStore {
                                tooltip_text: String::new(),
                                requires_argument: slash_command.requires_argument,
                            },
-                            wasm_extension.clone(),
-                            this.wasm_host.clone(),
                        );
                    }

@@ -1268,7 +1269,7 @@ impl ExtensionStore {
                        this.registration_hooks.register_context_server(
                            id.clone(),
                            wasm_extension.clone(),
-                            this.wasm_host.clone(),
+                            cx,
                        );
                    }

--- a/crates/extension_host/src/extension_lsp_adapter.rs
+++ b/crates/extension_host/src/extension_lsp_adapter.rs
@@ -5,6 +5,7 @@ use crate::wasm_host::{
 use anyhow::{anyhow, Context, Result};
 use async_trait::async_trait;
 use collections::HashMap;
+use extension::WorktreeDelegate;
 use futures::{Future, FutureExt};
 use gpui::AsyncAppContext;
 use language::{
@@ -18,6 +19,35 @@ use std::{any::Any, path::PathBuf, pin::Pin, sync::Arc};
 use util::{maybe, ResultExt};
 use wasmtime_wasi::WasiView as _;

+/// An adapter that allows an [`LspAdapterDelegate`] to be used as a [`WorktreeDelegate`].
+pub struct WorktreeDelegateAdapter(pub Arc<dyn LspAdapterDelegate>);
+
+#[async_trait]
+impl WorktreeDelegate for WorktreeDelegateAdapter {
+    fn id(&self) -> u64 {
+        self.0.worktree_id().to_proto()
+    }
+
+    fn root_path(&self) -> String {
+        self.0.worktree_root_path().to_string_lossy().to_string()
+    }
+
+    async fn read_text_file(&self, path: PathBuf) -> Result<String> {
+        self.0.read_text_file(path).await
+    }
+
+    async fn which(&self, binary_name: String) -> Option<String> {
+        self.0
+            .which(binary_name.as_ref())
+            .await
+            .map(|path| path.to_string_lossy().to_string())
+    }
+
+    async fn shell_env(&self) -> Vec<(String, String)> {
+        self.0.shell_env().await.into_iter().collect()
+    }
+}
+
 pub struct ExtensionLspAdapter {
    pub(crate) extension: WasmExtension,
    pub(crate) language_server_id: LanguageServerName,
@@ -45,6 +75,7 @@ impl LspAdapter for ExtensionLspAdapter {
                    let this = self.clone();
                    |extension, store| {
                        async move {
+                            let delegate = Arc::new(WorktreeDelegateAdapter(delegate.clone())) as _;
                            let resource = store.data_mut().table().push(delegate)?;
                            let command = extension
                                .call_language_server_command(
@@ -166,6 +197,7 @@ impl LspAdapter for ExtensionLspAdapter {
                let this = self.clone();
                |extension, store| {
                    async move {
+                        let delegate = Arc::new(WorktreeDelegateAdapter(delegate.clone())) as _;
                        let resource = store.data_mut().table().push(delegate)?;
                        let options = extension
                            .call_language_server_initialization_options(
@@ -204,6 +236,7 @@ impl LspAdapter for ExtensionLspAdapter {
                let this = self.clone();
                |extension, store| {
                    async move {
+                        let delegate = Arc::new(WorktreeDelegateAdapter(delegate.clone())) as _;
                        let resource = store.data_mut().table().push(delegate)?;
                        let options = extension
                            .call_language_server_workspace_configuration(
--- a/crates/extension_host/src/extension_store_test.rs
+++ b/crates/extension_host/src/extension_store_test.rs
@@ -1,20 +1,17 @@
-use assistant_slash_command::SlashCommandRegistry;
+use crate::extension_lsp_adapter::ExtensionLspAdapter;
+use crate::{
+    Event, ExtensionIndex, ExtensionIndexEntry, ExtensionIndexLanguageEntry,
+    ExtensionIndexThemeEntry, ExtensionManifest, ExtensionSettings, ExtensionStore,
+    GrammarManifestEntry, SchemaVersion, RELOAD_DEBOUNCE_DURATION,
+};
+use anyhow::Result;
 use async_compression::futures::bufread::GzipEncoder;
 use collections::BTreeMap;
-use context_servers::ContextServerFactoryRegistry;
-use extension_host::ExtensionSettings;
-use extension_host::SchemaVersion;
-use extension_host::{
-    Event, ExtensionIndex, ExtensionIndexEntry, ExtensionIndexLanguageEntry,
-    ExtensionIndexThemeEntry, ExtensionManifest, ExtensionStore, GrammarManifestEntry,
-    RELOAD_DEBOUNCE_DURATION,
-};
 use fs::{FakeFs, Fs, RealFs};
 use futures::{io::BufReader, AsyncReadExt, StreamExt};
-use gpui::{Context, SemanticVersion, TestAppContext};
+use gpui::{BackgroundExecutor, Context, SemanticVersion, SharedString, Task, TestAppContext};
 use http_client::{FakeHttpClient, Response};
-use indexed_docs::IndexedDocsRegistry;
-use language::{LanguageMatcher, LanguageRegistry, LanguageServerBinaryStatus};
+use language::{LanguageMatcher, LanguageRegistry, LanguageServerBinaryStatus, LoadedLanguage};
 use lsp::LanguageServerName;
 use node_runtime::NodeRuntime;
 use parking_lot::Mutex;
@@ -23,7 +20,6 @@ use release_channel::AppVersion;
 use reqwest_client::ReqwestClient;
 use serde_json::json;
 use settings::{Settings as _, SettingsStore};
-use snippet_provider::SnippetRegistry;
 use std::{
    ffi::OsString,
    path::{Path, PathBuf},
@@ -32,6 +28,84 @@ use std::{
 use theme::ThemeRegistry;
 use util::test::temp_tree;

+use crate::ExtensionRegistrationHooks;
+
+struct TestExtensionRegistrationHooks {
+    executor: BackgroundExecutor,
+    language_registry: Arc<LanguageRegistry>,
+    theme_registry: Arc<ThemeRegistry>,
+}
+
+impl ExtensionRegistrationHooks for TestExtensionRegistrationHooks {
+    fn list_theme_names(&self, path: PathBuf, fs: Arc<dyn Fs>) -> Task<Result<Vec<String>>> {
+        self.executor.spawn(async move {
+            let themes = theme::read_user_theme(&path, fs).await?;
+            Ok(themes.themes.into_iter().map(|theme| theme.name).collect())
+        })
+    }
+
+    fn load_user_theme(&self, theme_path: PathBuf, fs: Arc<dyn fs::Fs>) -> Task<Result<()>> {
+        let theme_registry = self.theme_registry.clone();
+        self.executor
+            .spawn(async move { theme_registry.load_user_theme(&theme_path, fs).await })
+    }
+
+    fn remove_user_themes(&self, themes: Vec<SharedString>) {
+        self.theme_registry.remove_user_themes(&themes);
+    }
+
+    fn register_language(
+        &self,
+        language: language::LanguageName,
+        grammar: Option<Arc<str>>,
+        matcher: language::LanguageMatcher,
+        load: Arc<dyn Fn() -> Result<LoadedLanguage> + 'static + Send + Sync>,
+    ) {
+        self.language_registry
+            .register_language(language, grammar, matcher, load)
+    }
+
+    fn remove_languages(
+        &self,
+        languages_to_remove: &[language::LanguageName],
+        grammars_to_remove: &[Arc<str>],
+    ) {
+        self.language_registry
+            .remove_languages(&languages_to_remove, &grammars_to_remove);
+    }
+
+    fn register_wasm_grammars(&self, grammars: Vec<(Arc<str>, PathBuf)>) {
+        self.language_registry.register_wasm_grammars(grammars)
+    }
+
+    fn register_lsp_adapter(
+        &self,
+        language_name: language::LanguageName,
+        adapter: ExtensionLspAdapter,
+    ) {
+        self.language_registry
+            .register_lsp_adapter(language_name, Arc::new(adapter));
+    }
+
+    fn update_lsp_status(
+        &self,
+        server_name: lsp::LanguageServerName,
+        status: LanguageServerBinaryStatus,
+    ) {
+        self.language_registry
+            .update_lsp_status(server_name, status);
+    }
+
+    fn remove_lsp_adapter(
+        &self,
+        language_name: &language::LanguageName,
+        server_name: &lsp::LanguageServerName,
+    ) {
+        self.language_registry
+            .remove_lsp_adapter(language_name, server_name);
+    }
+}
+
 #[cfg(test)]
 #[ctor::ctor]
 fn init_logger() {
@@ -265,27 +339,18 @@ async fn test_extension_store(cx: &mut TestAppContext) {

    let language_registry = Arc::new(LanguageRegistry::test(cx.executor()));
    let theme_registry = Arc::new(ThemeRegistry::new(Box::new(())));
-    let slash_command_registry = SlashCommandRegistry::new();
-    let indexed_docs_registry = Arc::new(IndexedDocsRegistry::new(cx.executor()));
-    let snippet_registry = Arc::new(SnippetRegistry::new());
-    let context_server_factory_registry = ContextServerFactoryRegistry::new();
+    let registration_hooks = Arc::new(TestExtensionRegistrationHooks {
+        executor: cx.executor(),
+        language_registry: language_registry.clone(),
+        theme_registry: theme_registry.clone(),
+    });
    let node_runtime = NodeRuntime::unavailable();

    let store = cx.new_model(|cx| {
-        let extension_registration_hooks = crate::ConcreteExtensionRegistrationHooks::new(
-            theme_registry.clone(),
-            slash_command_registry.clone(),
-            indexed_docs_registry.clone(),
-            snippet_registry.clone(),
-            language_registry.clone(),
-            context_server_factory_registry.clone(),
-            cx,
-        );
-
        ExtensionStore::new(
            PathBuf::from("/the-extension-dir"),
            None,
-            extension_registration_hooks,
+            registration_hooks.clone(),
            fs.clone(),
            http_client.clone(),
            http_client.clone(),
@@ -407,20 +472,10 @@ async fn test_extension_store(cx: &mut TestAppContext) {
    // Create new extension store, as if Zed were restarting.
    drop(store);
    let store = cx.new_model(|cx| {
-        let extension_api = crate::ConcreteExtensionRegistrationHooks::new(
-            theme_registry.clone(),
-            slash_command_registry,
-            indexed_docs_registry,
-            snippet_registry,
-            language_registry.clone(),
-            context_server_factory_registry.clone(),
-            cx,
-        );
-
        ExtensionStore::new(
            PathBuf::from("/the-extension-dir"),
            None,
-            extension_api,
+            registration_hooks,
            fs.clone(),
            http_client.clone(),
            http_client.clone(),
@@ -505,10 +560,11 @@ async fn test_extension_store_with_test_extension(cx: &mut TestAppContext) {

    let language_registry = project.read_with(cx, |project, _cx| project.languages().clone());
    let theme_registry = Arc::new(ThemeRegistry::new(Box::new(())));
-    let slash_command_registry = SlashCommandRegistry::new();
-    let indexed_docs_registry = Arc::new(IndexedDocsRegistry::new(cx.executor()));
-    let snippet_registry = Arc::new(SnippetRegistry::new());
-    let context_server_factory_registry = ContextServerFactoryRegistry::new();
+    let registration_hooks = Arc::new(TestExtensionRegistrationHooks {
+        executor: cx.executor(),
+        language_registry: language_registry.clone(),
+        theme_registry: theme_registry.clone(),
+    });
    let node_runtime = NodeRuntime::unavailable();

    let mut status_updates = language_registry.language_server_binary_statuses();
@@ -599,19 +655,10 @@ async fn test_extension_store_with_test_extension(cx: &mut TestAppContext) {
        Arc::new(ReqwestClient::user_agent(&user_agent).expect("Could not create HTTP client"));

    let extension_store = cx.new_model(|cx| {
-        let extension_api = crate::ConcreteExtensionRegistrationHooks::new(
-            theme_registry.clone(),
-            slash_command_registry,
-            indexed_docs_registry,
-            snippet_registry,
-            language_registry.clone(),
-            context_server_factory_registry.clone(),
-            cx,
-        );
        ExtensionStore::new(
            extensions_dir.clone(),
            Some(cache_dir),
-            extension_api,
+            registration_hooks,
            fs.clone(),
            extension_client.clone(),
            builder_client,
@@ -626,7 +673,7 @@ async fn test_extension_store_with_test_extension(cx: &mut TestAppContext) {
    let executor = cx.executor();
    let _task = cx.executor().spawn(async move {
        while let Some(event) = events.next().await {
-            if let extension_host::Event::StartedReloading = event {
+            if let Event::StartedReloading = event {
                executor.advance_clock(RELOAD_DEBOUNCE_DURATION);
            }
        }
--- a/crates/extension_host/src/wasm_host.rs
+++ b/crates/extension_host/src/wasm_host.rs
@@ -3,7 +3,10 @@ pub mod wit;
 use crate::{ExtensionManifest, ExtensionRegistrationHooks};
 use anyhow::{anyhow, bail, Context as _, Result};
 use async_trait::async_trait;
-use extension::KeyValueStoreDelegate;
+use extension::{
+    KeyValueStoreDelegate, SlashCommand, SlashCommandArgumentCompletion, SlashCommandOutput,
+    WorktreeDelegate,
+};
 use fs::{normalize_path, Fs};
 use futures::future::LocalBoxFuture;
 use futures::{
@@ -29,7 +32,7 @@ use wasmtime::{
 };
 use wasmtime_wasi::{self as wasi, WasiView};
 use wit::Extension;
-pub use wit::{ExtensionProject, SlashCommand};
+pub use wit::ExtensionProject;

 pub struct WasmHost {
    engine: Engine,
@@ -62,6 +65,51 @@ impl extension::Extension for WasmExtension {
        self.work_dir.clone()
    }

+    async fn complete_slash_command_argument(
+        &self,
+        command: SlashCommand,
+        arguments: Vec<String>,
+    ) -> Result<Vec<SlashCommandArgumentCompletion>> {
+        self.call(|extension, store| {
+            async move {
+                let completions = extension
+                    .call_complete_slash_command_argument(store, &command.into(), &arguments)
+                    .await?
+                    .map_err(|err| anyhow!("{err}"))?;
+
+                Ok(completions.into_iter().map(Into::into).collect())
+            }
+            .boxed()
+        })
+        .await
+    }
+
+    async fn run_slash_command(
+        &self,
+        command: SlashCommand,
+        arguments: Vec<String>,
+        delegate: Option<Arc<dyn WorktreeDelegate>>,
+    ) -> Result<SlashCommandOutput> {
+        self.call(|extension, store| {
+            async move {
+                let resource = if let Some(delegate) = delegate {
+                    Some(store.data_mut().table().push(delegate)?)
+                } else {
+                    None
+                };
+
+                let output = extension
+                    .call_run_slash_command(store, &command.into(), &arguments, resource)
+                    .await?
+                    .map_err(|err| anyhow!("{err}"))?;
+
+                Ok(output.into())
+            }
+            .boxed()
+        })
+        .await
+    }
+
    async fn suggest_docs_packages(&self, provider: Arc<str>) -> Result<Vec<String>> {
        self.call(|extension, store| {
            async move {
--- a/crates/extension_host/src/wasm_host/wit.rs
+++ b/crates/extension_host/src/wasm_host/wit.rs
@@ -3,14 +3,13 @@ mod since_v0_0_4;
 mod since_v0_0_6;
 mod since_v0_1_0;
 mod since_v0_2_0;
-use extension::KeyValueStoreDelegate;
+use extension::{KeyValueStoreDelegate, WorktreeDelegate};
 use lsp::LanguageServerName;
 use release_channel::ReleaseChannel;
 use since_v0_2_0 as latest;

 use super::{wasm_engine, WasmState};
 use anyhow::{anyhow, Context, Result};
-use language::LspAdapterDelegate;
 use semantic_version::SemanticVersion;
 use std::{ops::RangeInclusive, sync::Arc};
 use wasmtime::{
@@ -58,12 +57,35 @@ pub fn wasm_api_version_range(release_channel: ReleaseChannel) -> RangeInclusive

    let max_version = match release_channel {
        ReleaseChannel::Dev | ReleaseChannel::Nightly => latest::MAX_VERSION,
-        ReleaseChannel::Stable | ReleaseChannel::Preview => since_v0_1_0::MAX_VERSION,
+        ReleaseChannel::Stable | ReleaseChannel::Preview => latest::MAX_VERSION,
    };

    since_v0_0_1::MIN_VERSION..=max_version
 }

+/// Authorizes access to use unreleased versions of the Wasm API, based on the provided [`ReleaseChannel`].
+///
+/// Note: If there isn't currently an unreleased Wasm API version this function may be unused. Don't delete it!
+pub fn authorize_access_to_unreleased_wasm_api_version(
+    release_channel: ReleaseChannel,
+) -> Result<()> {
+    let allow_unreleased_version = match release_channel {
+        ReleaseChannel::Dev | ReleaseChannel::Nightly => true,
+        ReleaseChannel::Stable | ReleaseChannel::Preview => {
+            // We always allow the latest in tests so that the extension tests pass on release branches.
+            cfg!(any(test, feature = "test-support"))
+        }
+    };
+
+    if !allow_unreleased_version {
+        Err(anyhow!(
+            "unreleased versions of the extension API can only be used on development builds of Zed"
+        ))?;
+    }
+
+    Ok(())
+}
+
 pub enum Extension {
    V020(since_v0_2_0::Extension),
    V010(since_v0_1_0::Extension),
@@ -79,20 +101,10 @@ impl Extension {
        version: SemanticVersion,
        component: &Component,
    ) -> Result<Self> {
+        // Note: The release channel can be used to stage a new version of the extension API.
+        let _ = release_channel;
+
        if version >= latest::MIN_VERSION {
-            // Note: The release channel can be used to stage a new version of the extension API.
-            // We always allow the latest in tests so that the extension tests pass on release branches.
-            let allow_latest_version = match release_channel {
-                ReleaseChannel::Dev | ReleaseChannel::Nightly => true,
-                ReleaseChannel::Stable | ReleaseChannel::Preview => {
-                    cfg!(any(test, feature = "test-support"))
-                }
-            };
-            if !allow_latest_version {
-                Err(anyhow!(
-                    "unreleased versions of the extension API can only be used on development builds of Zed"
-                ))?;
-            }
            let extension =
                latest::Extension::instantiate_async(store, component, latest::linker())
                    .await
@@ -152,7 +164,7 @@ impl Extension {
        store: &mut Store<WasmState>,
        language_server_id: &LanguageServerName,
        config: &LanguageServerConfig,
-        resource: Resource<Arc<dyn LspAdapterDelegate>>,
+        resource: Resource<Arc<dyn WorktreeDelegate>>,
    ) -> Result<Result<Command, String>> {
        match self {
            Extension::V020(ext) => {
@@ -183,7 +195,7 @@ impl Extension {
        store: &mut Store<WasmState>,
        language_server_id: &LanguageServerName,
        config: &LanguageServerConfig,
-        resource: Resource<Arc<dyn LspAdapterDelegate>>,
+        resource: Resource<Arc<dyn WorktreeDelegate>>,
    ) -> Result<Result<Option<String>, String>> {
        match self {
            Extension::V020(ext) => {
@@ -229,7 +241,7 @@ impl Extension {
        &self,
        store: &mut Store<WasmState>,
        language_server_id: &LanguageServerName,
-        resource: Resource<Arc<dyn LspAdapterDelegate>>,
+        resource: Resource<Arc<dyn WorktreeDelegate>>,
    ) -> Result<Result<Option<String>, String>> {
        match self {
            Extension::V020(ext) => {
@@ -366,7 +378,7 @@ impl Extension {
        store: &mut Store<WasmState>,
        command: &SlashCommand,
        arguments: &[String],
-        resource: Option<Resource<Arc<dyn LspAdapterDelegate>>>,
+        resource: Option<Resource<Arc<dyn WorktreeDelegate>>>,
    ) -> Result<Result<SlashCommandOutput, String>> {
        match self {
            Extension::V020(ext) => {
--- a/crates/extension_host/src/wasm_host/wit/since_v0_0_1.rs
+++ b/crates/extension_host/src/wasm_host/wit/since_v0_0_1.rs
@@ -3,7 +3,8 @@ use crate::wasm_host::wit::since_v0_0_4;
 use crate::wasm_host::WasmState;
 use anyhow::Result;
 use async_trait::async_trait;
-use language::{LanguageServerBinaryStatus, LspAdapterDelegate};
+use extension::WorktreeDelegate;
+use language::LanguageServerBinaryStatus;
 use semantic_version::SemanticVersion;
 use std::sync::{Arc, OnceLock};
 use wasmtime::component::{Linker, Resource};
@@ -21,7 +22,7 @@ wasmtime::component::bindgen!({
    },
 });

-pub type ExtensionWorktree = Arc<dyn LspAdapterDelegate>;
+pub type ExtensionWorktree = Arc<dyn WorktreeDelegate>;

 pub fn linker() -> &'static Linker<WasmState> {
    static LINKER: OnceLock<Linker<WasmState>> = OnceLock::new();
@@ -62,7 +63,7 @@ impl From<Command> for latest::Command {
 impl HostWorktree for WasmState {
    async fn read_text_file(
        &mut self,
-        delegate: Resource<Arc<dyn LspAdapterDelegate>>,
+        delegate: Resource<Arc<dyn WorktreeDelegate>>,
        path: String,
    ) -> wasmtime::Result<Result<String, String>> {
        latest::HostWorktree::read_text_file(self, delegate, path).await
@@ -70,14 +71,14 @@ impl HostWorktree for WasmState {

    async fn shell_env(
        &mut self,
-        delegate: Resource<Arc<dyn LspAdapterDelegate>>,
+        delegate: Resource<Arc<dyn WorktreeDelegate>>,
    ) -> wasmtime::Result<EnvVars> {
        latest::HostWorktree::shell_env(self, delegate).await
    }

    async fn which(
        &mut self,
-        delegate: Resource<Arc<dyn LspAdapterDelegate>>,
+        delegate: Resource<Arc<dyn WorktreeDelegate>>,
        binary_name: String,
    ) -> wasmtime::Result<Option<String>> {
        latest::HostWorktree::which(self, delegate, binary_name).await
--- a/crates/extension_host/src/wasm_host/wit/since_v0_0_4.rs
+++ b/crates/extension_host/src/wasm_host/wit/since_v0_0_4.rs
@@ -2,7 +2,7 @@ use super::latest;
 use crate::wasm_host::WasmState;
 use anyhow::Result;
 use async_trait::async_trait;
-use language::LspAdapterDelegate;
+use extension::WorktreeDelegate;
 use semantic_version::SemanticVersion;
 use std::sync::{Arc, OnceLock};
 use wasmtime::component::{Linker, Resource};
@@ -20,7 +20,7 @@ wasmtime::component::bindgen!({
    },
 });

-pub type ExtensionWorktree = Arc<dyn LspAdapterDelegate>;
+pub type ExtensionWorktree = Arc<dyn WorktreeDelegate>;

 pub fn linker() -> &'static Linker<WasmState> {
    static LINKER: OnceLock<Linker<WasmState>> = OnceLock::new();
@@ -71,7 +71,7 @@ impl From<Command> for latest::Command {
 impl HostWorktree for WasmState {
    async fn read_text_file(
        &mut self,
-        delegate: Resource<Arc<dyn LspAdapterDelegate>>,
+        delegate: Resource<Arc<dyn WorktreeDelegate>>,
        path: String,
    ) -> wasmtime::Result<Result<String, String>> {
        latest::HostWorktree::read_text_file(self, delegate, path).await
@@ -79,14 +79,14 @@ impl HostWorktree for WasmState {

    async fn shell_env(
        &mut self,
-        delegate: Resource<Arc<dyn LspAdapterDelegate>>,
+        delegate: Resource<Arc<dyn WorktreeDelegate>>,
    ) -> wasmtime::Result<EnvVars> {
        latest::HostWorktree::shell_env(self, delegate).await
    }

    async fn which(
        &mut self,
-        delegate: Resource<Arc<dyn LspAdapterDelegate>>,
+        delegate: Resource<Arc<dyn WorktreeDelegate>>,
        binary_name: String,
    ) -> wasmtime::Result<Option<String>> {
        latest::HostWorktree::which(self, delegate, binary_name).await
--- a/crates/extension_host/src/wasm_host/wit/since_v0_0_6.rs
+++ b/crates/extension_host/src/wasm_host/wit/since_v0_0_6.rs
@@ -2,7 +2,7 @@ use super::{latest, since_v0_1_0};
 use crate::wasm_host::WasmState;
 use anyhow::Result;
 use async_trait::async_trait;
-use language::LspAdapterDelegate;
+use extension::WorktreeDelegate;
 use semantic_version::SemanticVersion;
 use std::sync::{Arc, OnceLock};
 use wasmtime::component::{Linker, Resource};
@@ -26,7 +26,7 @@ mod settings {
    include!(concat!(env!("OUT_DIR"), "/since_v0.0.6/settings.rs"));
 }

-pub type ExtensionWorktree = Arc<dyn LspAdapterDelegate>;
+pub type ExtensionWorktree = Arc<dyn WorktreeDelegate>;

 pub fn linker() -> &'static Linker<WasmState> {
    static LINKER: OnceLock<Linker<WasmState>> = OnceLock::new();
@@ -113,23 +113,20 @@ impl From<CodeLabel> for latest::CodeLabel {

 #[async_trait]
 impl HostWorktree for WasmState {
-    async fn id(
-        &mut self,
-        delegate: Resource<Arc<dyn LspAdapterDelegate>>,
-    ) -> wasmtime::Result<u64> {
+    async fn id(&mut self, delegate: Resource<Arc<dyn WorktreeDelegate>>) -> wasmtime::Result<u64> {
        latest::HostWorktree::id(self, delegate).await
    }

    async fn root_path(
        &mut self,
-        delegate: Resource<Arc<dyn LspAdapterDelegate>>,
+        delegate: Resource<Arc<dyn WorktreeDelegate>>,
    ) -> wasmtime::Result<String> {
        latest::HostWorktree::root_path(self, delegate).await
    }

    async fn read_text_file(
        &mut self,
-        delegate: Resource<Arc<dyn LspAdapterDelegate>>,
+        delegate: Resource<Arc<dyn WorktreeDelegate>>,
        path: String,
    ) -> wasmtime::Result<Result<String, String>> {
        latest::HostWorktree::read_text_file(self, delegate, path).await
@@ -137,14 +134,14 @@ impl HostWorktree for WasmState {

    async fn shell_env(
        &mut self,
-        delegate: Resource<Arc<dyn LspAdapterDelegate>>,
+        delegate: Resource<Arc<dyn WorktreeDelegate>>,
    ) -> wasmtime::Result<EnvVars> {
        latest::HostWorktree::shell_env(self, delegate).await
    }

    async fn which(
        &mut self,
-        delegate: Resource<Arc<dyn LspAdapterDelegate>>,
+        delegate: Resource<Arc<dyn WorktreeDelegate>>,
        binary_name: String,
    ) -> wasmtime::Result<Option<String>> {
        latest::HostWorktree::which(self, delegate, binary_name).await
--- a/crates/extension_host/src/wasm_host/wit/since_v0_1_0.rs
+++ b/crates/extension_host/src/wasm_host/wit/since_v0_1_0.rs
@@ -5,13 +5,11 @@ use anyhow::{anyhow, bail, Context, Result};
 use async_compression::futures::bufread::GzipDecoder;
 use async_tar::Archive;
 use async_trait::async_trait;
-use extension::KeyValueStoreDelegate;
+use extension::{KeyValueStoreDelegate, WorktreeDelegate};
 use futures::{io::BufReader, FutureExt as _};
 use futures::{lock::Mutex, AsyncReadExt};
 use language::LanguageName;
-use language::{
-    language_settings::AllLanguageSettings, LanguageServerBinaryStatus, LspAdapterDelegate,
-};
+use language::{language_settings::AllLanguageSettings, LanguageServerBinaryStatus};
 use project::project_settings::ProjectSettings;
 use semantic_version::SemanticVersion;
 use std::{
@@ -24,7 +22,6 @@ use wasmtime::component::{Linker, Resource};
 use super::latest;

 pub const MIN_VERSION: SemanticVersion = SemanticVersion::new(0, 1, 0);
-pub const MAX_VERSION: SemanticVersion = SemanticVersion::new(0, 1, 0);

 wasmtime::component::bindgen!({
    async: true,
@@ -47,7 +44,7 @@ mod settings {
    include!(concat!(env!("OUT_DIR"), "/since_v0.1.0/settings.rs"));
 }

-pub type ExtensionWorktree = Arc<dyn LspAdapterDelegate>;
+pub type ExtensionWorktree = Arc<dyn WorktreeDelegate>;
 pub type ExtensionKeyValueStore = Arc<dyn KeyValueStoreDelegate>;
 pub type ExtensionHttpResponseStream = Arc<Mutex<::http_client::Response<AsyncBody>>>;

@@ -251,52 +248,38 @@ impl HostKeyValueStore for WasmState {

 #[async_trait]
 impl HostWorktree for WasmState {
-    async fn id(
-        &mut self,
-        delegate: Resource<Arc<dyn LspAdapterDelegate>>,
-    ) -> wasmtime::Result<u64> {
-        let delegate = self.table.get(&delegate)?;
-        Ok(delegate.worktree_id().to_proto())
+    async fn id(&mut self, delegate: Resource<Arc<dyn WorktreeDelegate>>) -> wasmtime::Result<u64> {
+        latest::HostWorktree::id(self, delegate).await
    }

    async fn root_path(
        &mut self,
-        delegate: Resource<Arc<dyn LspAdapterDelegate>>,
+        delegate: Resource<Arc<dyn WorktreeDelegate>>,
    ) -> wasmtime::Result<String> {
-        let delegate = self.table.get(&delegate)?;
-        Ok(delegate.worktree_root_path().to_string_lossy().to_string())
+        latest::HostWorktree::root_path(self, delegate).await
    }

    async fn read_text_file(
        &mut self,
-        delegate: Resource<Arc<dyn LspAdapterDelegate>>,
+        delegate: Resource<Arc<dyn WorktreeDelegate>>,
        path: String,
    ) -> wasmtime::Result<Result<String, String>> {
-        let delegate = self.table.get(&delegate)?;
-        Ok(delegate
-            .read_text_file(path.into())
-            .await
-            .map_err(|error| error.to_string()))
+        latest::HostWorktree::read_text_file(self, delegate, path).await
    }

    async fn shell_env(
        &mut self,
-        delegate: Resource<Arc<dyn LspAdapterDelegate>>,
+        delegate: Resource<Arc<dyn WorktreeDelegate>>,
    ) -> wasmtime::Result<EnvVars> {
-        let delegate = self.table.get(&delegate)?;
-        Ok(delegate.shell_env().await.into_iter().collect())
+        latest::HostWorktree::shell_env(self, delegate).await
    }

    async fn which(
        &mut self,
-        delegate: Resource<Arc<dyn LspAdapterDelegate>>,
+        delegate: Resource<Arc<dyn WorktreeDelegate>>,
        binary_name: String,
    ) -> wasmtime::Result<Option<String>> {
-        let delegate = self.table.get(&delegate)?;
-        Ok(delegate
-            .which(binary_name.as_ref())
-            .await
-            .map(|path| path.to_string_lossy().to_string()))
+        latest::HostWorktree::which(self, delegate, binary_name).await
    }

    fn drop(&mut self, _worktree: Resource<Worktree>) -> Result<()> {
--- a/crates/extension_host/src/wasm_host/wit/since_v0_2_0.rs
+++ b/crates/extension_host/src/wasm_host/wit/since_v0_2_0.rs
@@ -1,3 +1,4 @@
+use crate::wasm_host::wit::since_v0_2_0::slash_command::SlashCommandOutputSection;
 use crate::wasm_host::{wit::ToWasmtimeResult, WasmState};
 use ::http_client::{AsyncBody, HttpRequestExt};
 use ::settings::{Settings, WorktreeId};
@@ -6,13 +7,10 @@ use async_compression::futures::bufread::GzipDecoder;
 use async_tar::Archive;
 use async_trait::async_trait;
 use context_servers::manager::ContextServerSettings;
-use extension::KeyValueStoreDelegate;
+use extension::{KeyValueStoreDelegate, WorktreeDelegate};
 use futures::{io::BufReader, FutureExt as _};
 use futures::{lock::Mutex, AsyncReadExt};
-use language::{
-    language_settings::AllLanguageSettings, LanguageName, LanguageServerBinaryStatus,
-    LspAdapterDelegate,
-};
+use language::{language_settings::AllLanguageSettings, LanguageName, LanguageServerBinaryStatus};
 use project::project_settings::ProjectSettings;
 use semantic_version::SemanticVersion;
 use std::{
@@ -44,7 +42,7 @@ mod settings {
    include!(concat!(env!("OUT_DIR"), "/since_v0.2.0/settings.rs"));
 }

-pub type ExtensionWorktree = Arc<dyn LspAdapterDelegate>;
+pub type ExtensionWorktree = Arc<dyn WorktreeDelegate>;
 pub type ExtensionKeyValueStore = Arc<dyn KeyValueStoreDelegate>;
 pub type ExtensionHttpResponseStream = Arc<Mutex<::http_client::Response<AsyncBody>>>;

@@ -57,6 +55,45 @@ pub fn linker() -> &'static Linker<WasmState> {
    LINKER.get_or_init(|| super::new_linker(Extension::add_to_linker))
 }

+impl From<extension::SlashCommand> for SlashCommand {
+    fn from(value: extension::SlashCommand) -> Self {
+        Self {
+            name: value.name,
+            description: value.description,
+            tooltip_text: value.tooltip_text,
+            requires_argument: value.requires_argument,
+        }
+    }
+}
+
+impl From<SlashCommandOutput> for extension::SlashCommandOutput {
+    fn from(value: SlashCommandOutput) -> Self {
+        Self {
+            text: value.text,
+            sections: value.sections.into_iter().map(Into::into).collect(),
+        }
+    }
+}
+
+impl From<SlashCommandOutputSection> for extension::SlashCommandOutputSection {
+    fn from(value: SlashCommandOutputSection) -> Self {
+        Self {
+            range: value.range.start as usize..value.range.end as usize,
+            label: value.label,
+        }
+    }
+}
+
+impl From<SlashCommandArgumentCompletion> for extension::SlashCommandArgumentCompletion {
+    fn from(value: SlashCommandArgumentCompletion) -> Self {
+        Self {
+            label: value.label,
+            new_text: value.new_text,
+            run_command: value.run_command,
+        }
+    }
+}
+
 #[async_trait]
 impl HostKeyValueStore for WasmState {
    async fn insert(
@@ -93,25 +130,22 @@ impl HostProject for WasmState {

 #[async_trait]
 impl HostWorktree for WasmState {
-    async fn id(
-        &mut self,
-        delegate: Resource<Arc<dyn LspAdapterDelegate>>,
-    ) -> wasmtime::Result<u64> {
+    async fn id(&mut self, delegate: Resource<Arc<dyn WorktreeDelegate>>) -> wasmtime::Result<u64> {
        let delegate = self.table.get(&delegate)?;
-        Ok(delegate.worktree_id().to_proto())
+        Ok(delegate.id())
    }

    async fn root_path(
        &mut self,
-        delegate: Resource<Arc<dyn LspAdapterDelegate>>,
+        delegate: Resource<Arc<dyn WorktreeDelegate>>,
    ) -> wasmtime::Result<String> {
        let delegate = self.table.get(&delegate)?;
-        Ok(delegate.worktree_root_path().to_string_lossy().to_string())
+        Ok(delegate.root_path())
    }

    async fn read_text_file(
        &mut self,
-        delegate: Resource<Arc<dyn LspAdapterDelegate>>,
+        delegate: Resource<Arc<dyn WorktreeDelegate>>,
        path: String,
    ) -> wasmtime::Result<Result<String, String>> {
        let delegate = self.table.get(&delegate)?;
@@ -123,7 +157,7 @@ impl HostWorktree for WasmState {

    async fn shell_env(
        &mut self,
-        delegate: Resource<Arc<dyn LspAdapterDelegate>>,
+        delegate: Resource<Arc<dyn WorktreeDelegate>>,
    ) -> wasmtime::Result<EnvVars> {
        let delegate = self.table.get(&delegate)?;
        Ok(delegate.shell_env().await.into_iter().collect())
@@ -131,14 +165,11 @@ impl HostWorktree for WasmState {

    async fn which(
        &mut self,
-        delegate: Resource<Arc<dyn LspAdapterDelegate>>,
+        delegate: Resource<Arc<dyn WorktreeDelegate>>,
        binary_name: String,
    ) -> wasmtime::Result<Option<String>> {
        let delegate = self.table.get(&delegate)?;
-        Ok(delegate
-            .which(binary_name.as_ref())
-            .await
-            .map(|path| path.to_string_lossy().to_string()))
+        Ok(delegate.which(binary_name).await)
    }

    fn drop(&mut self, _worktree: Resource<Worktree>) -> Result<()> {
--- a/crates/extensions_ui/Cargo.toml
+++ b/crates/extensions_ui/Cargo.toml
@@ -11,13 +11,9 @@ workspace = true
 [lib]
 path = "src/extensions_ui.rs"

-[features]
-test-support = []
-
 [dependencies]
 anyhow.workspace = true
 assistant_slash_command.workspace = true
-async-trait.workspace = true
 client.workspace = true
 collections.workspace = true
 context_servers.workspace = true
@@ -26,11 +22,11 @@ editor.workspace = true
 extension.workspace = true
 extension_host.workspace = true
 fs.workspace = true
-futures.workspace = true
 fuzzy.workspace = true
 gpui.workspace = true
 indexed_docs.workspace = true
 language.workspace = true
+log.workspace = true
 lsp.workspace = true
 num-format.workspace = true
 picker.workspace = true
@@ -50,21 +46,4 @@ wasmtime-wasi.workspace = true
 workspace.workspace = true

 [dev-dependencies]
-async-compression.workspace = true
-async-tar.workspace = true
-ctor.workspace = true
 editor = { workspace = true, features = ["test-support"] }
-env_logger.workspace = true
-extension_host = {workspace = true, features = ["test-support"] }
-fs = { workspace = true, features = ["test-support"] }
-gpui = { workspace = true, features = ["test-support"] }
-http_client.workspace = true
-indexed_docs.workspace = true
-language = { workspace = true, features = ["test-support"] }
-lsp.workspace = true
-node_runtime.workspace = true
-parking_lot.workspace = true
-project = { workspace = true, features = ["test-support"] }
-reqwest_client.workspace = true
-serde_json.workspace = true
-workspace = { workspace = true, features = ["test-support"] }
--- a/crates/extensions_ui/src/extension_context_server.rs
+++ b/crates/extensions_ui/src/extension_context_server.rs
@@ -1,97 +0,0 @@
-use std::pin::Pin;
-use std::sync::Arc;
-
-use anyhow::{anyhow, Result};
-use async_trait::async_trait;
-use context_servers::manager::{NativeContextServer, ServerCommand, ServerConfig};
-use context_servers::protocol::InitializedContextServerProtocol;
-use context_servers::ContextServer;
-use extension_host::wasm_host::{ExtensionProject, WasmExtension, WasmHost};
-use futures::{Future, FutureExt};
-use gpui::{AsyncAppContext, Model};
-use project::Project;
-use wasmtime_wasi::WasiView as _;
-
-pub struct ExtensionContextServer {
-    #[allow(unused)]
-    pub(crate) extension: WasmExtension,
-    #[allow(unused)]
-    pub(crate) host: Arc<WasmHost>,
-    id: Arc<str>,
-    context_server: Arc<NativeContextServer>,
-}
-
-impl ExtensionContextServer {
-    pub async fn new(
-        extension: WasmExtension,
-        host: Arc<WasmHost>,
-        id: Arc<str>,
-        project: Model<Project>,
-        mut cx: AsyncAppContext,
-    ) -> Result<Self> {
-        let extension_project = project.update(&mut cx, |project, cx| ExtensionProject {
-            worktree_ids: project
-                .visible_worktrees(cx)
-                .map(|worktree| worktree.read(cx).id().to_proto())
-                .collect(),
-        })?;
-        let command = extension
-            .call({
-                let id = id.clone();
-                |extension, store| {
-                    async move {
-                        let project = store.data_mut().table().push(extension_project)?;
-                        let command = extension
-                            .call_context_server_command(store, id.clone(), project)
-                            .await?
-                            .map_err(|e| anyhow!("{}", e))?;
-                        anyhow::Ok(command)
-                    }
-                    .boxed()
-                }
-            })
-            .await?;
-
-        let config = Arc::new(ServerConfig {
-            settings: None,
-            command: Some(ServerCommand {
-                path: command.command,
-                args: command.args,
-                env: Some(command.env.into_iter().collect()),
-            }),
-        });
-
-        anyhow::Ok(Self {
-            extension,
-            host,
-            id: id.clone(),
-            context_server: Arc::new(NativeContextServer::new(id, config)),
-        })
-    }
-}
-
-#[async_trait(?Send)]
-impl ContextServer for ExtensionContextServer {
-    fn id(&self) -> Arc<str> {
-        self.id.clone()
-    }
-
-    fn config(&self) -> Arc<ServerConfig> {
-        self.context_server.config()
-    }
-
-    fn client(&self) -> Option<Arc<InitializedContextServerProtocol>> {
-        self.context_server.client()
-    }
-
-    fn start<'a>(
-        self: Arc<Self>,
-        cx: &'a AsyncAppContext,
-    ) -> Pin<Box<dyn 'a + Future<Output = Result<()>>>> {
-        self.context_server.clone().start(cx)
-    }
-
-    fn stop(&self) -> Result<()> {
-        self.context_server.stop()
-    }
-}
--- a/crates/extensions_ui/src/extension_registration_hooks.rs
+++ b/crates/extensions_ui/src/extension_registration_hooks.rs
@@ -1,20 +1,21 @@
 use std::{path::PathBuf, sync::Arc};

-use anyhow::Result;
-use assistant_slash_command::SlashCommandRegistry;
+use anyhow::{anyhow, Result};
+use assistant_slash_command::{ExtensionSlashCommand, SlashCommandRegistry};
+use context_servers::manager::ServerCommand;
 use context_servers::ContextServerFactoryRegistry;
+use db::smol::future::FutureExt as _;
 use extension::Extension;
+use extension_host::wasm_host::ExtensionProject;
 use extension_host::{extension_lsp_adapter::ExtensionLspAdapter, wasm_host};
 use fs::Fs;
-use gpui::{AppContext, BackgroundExecutor, Task};
+use gpui::{AppContext, BackgroundExecutor, Model, Task};
 use indexed_docs::{ExtensionIndexedDocsProvider, IndexedDocsRegistry, ProviderId};
 use language::{LanguageRegistry, LanguageServerBinaryStatus, LoadedLanguage};
 use snippet_provider::SnippetRegistry;
 use theme::{ThemeRegistry, ThemeSettings};
 use ui::SharedString;
-
-use crate::extension_context_server::ExtensionContextServer;
-use crate::extension_slash_command::ExtensionSlashCommand;
+use wasmtime_wasi::WasiView as _;

 pub struct ConcreteExtensionRegistrationHooks {
    slash_command_registry: Arc<SlashCommandRegistry>,
@@ -22,7 +23,7 @@ pub struct ConcreteExtensionRegistrationHooks {
    indexed_docs_registry: Arc<IndexedDocsRegistry>,
    snippet_registry: Arc<SnippetRegistry>,
    language_registry: Arc<LanguageRegistry>,
-    context_server_factory_registry: Arc<ContextServerFactoryRegistry>,
+    context_server_factory_registry: Model<ContextServerFactoryRegistry>,
    executor: BackgroundExecutor,
 }

@@ -33,7 +34,7 @@ impl ConcreteExtensionRegistrationHooks {
        indexed_docs_registry: Arc<IndexedDocsRegistry>,
        snippet_registry: Arc<SnippetRegistry>,
        language_registry: Arc<LanguageRegistry>,
-        context_server_factory_registry: Arc<ContextServerFactoryRegistry>,
+        context_server_factory_registry: Model<ContextServerFactoryRegistry>,
        cx: &AppContext,
    ) -> Arc<dyn extension_host::ExtensionRegistrationHooks> {
        Arc::new(Self {
@@ -61,43 +62,77 @@ impl extension_host::ExtensionRegistrationHooks for ConcreteExtensionRegistratio

    fn register_slash_command(
        &self,
-        command: wasm_host::SlashCommand,
-        extension: wasm_host::WasmExtension,
-        host: Arc<wasm_host::WasmHost>,
+        extension: Arc<dyn Extension>,
+        command: extension::SlashCommand,
    ) {
-        self.slash_command_registry.register_command(
-            ExtensionSlashCommand {
-                command,
-                extension,
-                host,
-            },
-            false,
-        )
+        self.slash_command_registry
+            .register_command(ExtensionSlashCommand::new(extension, command), false)
    }

    fn register_context_server(
        &self,
        id: Arc<str>,
        extension: wasm_host::WasmExtension,
-        host: Arc<wasm_host::WasmHost>,
+        cx: &mut AppContext,
    ) {
        self.context_server_factory_registry
-            .register_server_factory(
-                id.clone(),
-                Arc::new({
-                    move |project, cx| {
-                        let id = id.clone();
-                        let extension = extension.clone();
-                        let host = host.clone();
-                        cx.spawn(|cx| async move {
-                            let context_server =
-                                ExtensionContextServer::new(extension, host, id, project, cx)
+            .update(cx, |registry, _| {
+                registry.register_server_factory(
+                    id.clone(),
+                    Arc::new({
+                        move |project, cx| {
+                            log::info!(
+                                "loading command for context server {id} from extension {}",
+                                extension.manifest.id
+                            );
+
+                            let id = id.clone();
+                            let extension = extension.clone();
+                            cx.spawn(|mut cx| async move {
+                                let extension_project =
+                                    project.update(&mut cx, |project, cx| ExtensionProject {
+                                        worktree_ids: project
+                                            .visible_worktrees(cx)
+                                            .map(|worktree| worktree.read(cx).id().to_proto())
+                                            .collect(),
+                                    })?;
+
+                                let command = extension
+                                    .call({
+                                        let id = id.clone();
+                                        |extension, store| {
+                                            async move {
+                                                let project = store
+                                                    .data_mut()
+                                                    .table()
+                                                    .push(extension_project)?;
+                                                let command = extension
+                                                    .call_context_server_command(
+                                                        store,
+                                                        id.clone(),
+                                                        project,
+                                                    )
+                                                    .await?
+                                                    .map_err(|e| anyhow!("{}", e))?;
+                                                anyhow::Ok(command)
+                                            }
+                                            .boxed()
+                                        }
+                                    })
                                    .await?;
-                            anyhow::Ok(Arc::new(context_server) as _)
-                        })
-                    }
-                }),
-            );
+
+                                log::info!("loaded command for context server {id}: {command:?}");
+
+                                Ok(ServerCommand {
+                                    path: command.command,
+                                    args: command.args,
+                                    env: Some(command.env.into_iter().collect()),
+                                })
+                            })
+                        }
+                    }),
+                )
+            });
    }

    fn register_docs_provider(&self, extension: Arc<dyn Extension>, provider_id: Arc<str>) {
--- a/crates/extensions_ui/src/extension_slash_command.rs
+++ b/crates/extensions_ui/src/extension_slash_command.rs
@@ -1,135 +0,0 @@
-use std::sync::{atomic::AtomicBool, Arc};
-
-use anyhow::{anyhow, Result};
-use assistant_slash_command::{
-    ArgumentCompletion, SlashCommand, SlashCommandOutput, SlashCommandOutputSection,
-    SlashCommandResult,
-};
-use futures::FutureExt as _;
-use gpui::{Task, WeakView, WindowContext};
-use language::{BufferSnapshot, LspAdapterDelegate};
-use ui::prelude::*;
-use wasmtime_wasi::WasiView;
-use workspace::Workspace;
-
-use extension_host::wasm_host::{WasmExtension, WasmHost};
-
-pub struct ExtensionSlashCommand {
-    pub(crate) extension: WasmExtension,
-    #[allow(unused)]
-    pub(crate) host: Arc<WasmHost>,
-    pub(crate) command: extension_host::wasm_host::SlashCommand,
-}
-
-impl SlashCommand for ExtensionSlashCommand {
-    fn name(&self) -> String {
-        self.command.name.clone()
-    }
-
-    fn description(&self) -> String {
-        self.command.description.clone()
-    }
-
-    fn menu_text(&self) -> String {
-        self.command.tooltip_text.clone()
-    }
-
-    fn requires_argument(&self) -> bool {
-        self.command.requires_argument
-    }
-
-    fn complete_argument(
-        self: Arc<Self>,
-        arguments: &[String],
-        _cancel: Arc<AtomicBool>,
-        _workspace: Option<WeakView<Workspace>>,
-        cx: &mut WindowContext,
-    ) -> Task<Result<Vec<ArgumentCompletion>>> {
-        let arguments = arguments.to_owned();
-        cx.background_executor().spawn(async move {
-            self.extension
-                .call({
-                    let this = self.clone();
-                    move |extension, store| {
-                        async move {
-                            let completions = extension
-                                .call_complete_slash_command_argument(
-                                    store,
-                                    &this.command,
-                                    &arguments,
-                                )
-                                .await?
-                                .map_err(|e| anyhow!("{}", e))?;
-
-                            anyhow::Ok(
-                                completions
-                                    .into_iter()
-                                    .map(|completion| ArgumentCompletion {
-                                        label: completion.label.into(),
-                                        new_text: completion.new_text,
-                                        replace_previous_arguments: false,
-                                        after_completion: completion.run_command.into(),
-                                    })
-                                    .collect(),
-                            )
-                        }
-                        .boxed()
-                    }
-                })
-                .await
-        })
-    }
-
-    fn run(
-        self: Arc<Self>,
-        arguments: &[String],
-        _context_slash_command_output_sections: &[SlashCommandOutputSection<language::Anchor>],
-        _context_buffer: BufferSnapshot,
-        _workspace: WeakView<Workspace>,
-        delegate: Option<Arc<dyn LspAdapterDelegate>>,
-        cx: &mut WindowContext,
-    ) -> Task<SlashCommandResult> {
-        let arguments = arguments.to_owned();
-        let output = cx.background_executor().spawn(async move {
-            self.extension
-                .call({
-                    let this = self.clone();
-                    move |extension, store| {
-                        async move {
-                            let resource = if let Some(delegate) = delegate {
-                                Some(store.data_mut().table().push(delegate)?)
-                            } else {
-                                None
-                            };
-                            let output = extension
-                                .call_run_slash_command(store, &this.command, &arguments, resource)
-                                .await?
-                                .map_err(|e| anyhow!("{}", e))?;
-
-                            anyhow::Ok(output)
-                        }
-                        .boxed()
-                    }
-                })
-                .await
-        });
-        cx.foreground_executor().spawn(async move {
-            let output = output.await?;
-            Ok(SlashCommandOutput {
-                text: output.text,
-                sections: output
-                    .sections
-                    .into_iter()
-                    .map(|section| SlashCommandOutputSection {
-                        range: section.range.into(),
-                        icon: IconName::Code,
-                        label: section.label.into(),
-                        metadata: None,
-                    })
-                    .collect(),
-                run_commands_in_text: false,
-            }
-            .to_event_stream())
-        })
-    }
-}
--- a/crates/extensions_ui/src/extensions_ui.rs
+++ b/crates/extensions_ui/src/extensions_ui.rs
@@ -1,13 +1,8 @@
 mod components;
-mod extension_context_server;
 mod extension_registration_hooks;
-mod extension_slash_command;
 mod extension_suggest;
 mod extension_version_selector;

-#[cfg(test)]
-mod extension_store_test;
-
 pub use extension_registration_hooks::ConcreteExtensionRegistrationHooks;

 use std::ops::DerefMut;
--- a/crates/gpui/examples/input.rs
+++ b/crates/gpui/examples/input.rs
@@ -580,9 +580,9 @@ impl Render for InputExample {
            .children(self.recent_keystrokes.iter().rev().map(|ks| {
                format!(
                    "{:} {}",
-                    ks,
-                    if let Some(ime_key) = ks.ime_key.as_ref() {
-                        format!("-> {}", ime_key)
+                    ks.unparse(),
+                    if let Some(key_char) = ks.key_char.as_ref() {
+                        format!("-> {:?}", key_char)
                    } else {
                        "".to_owned()
                    }
--- a/crates/gpui/src/platform.rs
+++ b/crates/gpui/src/platform.rs
@@ -688,6 +688,11 @@ impl PlatformInputHandler {
            .flatten()
    }

+    #[allow(dead_code)]
+    fn apple_press_and_hold_enabled(&mut self) -> bool {
+        self.handler.apple_press_and_hold_enabled()
+    }
+
    pub(crate) fn dispatch_input(&mut self, input: &str, cx: &mut WindowContext) {
        self.handler.replace_text_in_range(None, input, cx);
    }
@@ -785,6 +790,15 @@ pub trait InputHandler: 'static {
        range_utf16: Range<usize>,
        cx: &mut WindowContext,
    ) -> Option<Bounds<Pixels>>;
+
+    /// Allows a given input context to opt into getting raw key repeats instead of
+    /// sending these to the platform.
+    /// TODO: Ideally we should be able to set ApplePressAndHoldEnabled in NSUserDefaults
+    /// (which is how iTerm does it) but it doesn't seem to work for me.
+    #[allow(dead_code)]
+    fn apple_press_and_hold_enabled(&mut self) -> bool {
+        true
+    }
 }

 /// The variables that can be configured when creating a new window
--- a/crates/gpui/src/platform/keystroke.rs
+++ b/crates/gpui/src/platform/keystroke.rs
@@ -12,14 +12,15 @@ pub struct Keystroke {
    /// e.g. for option-s, key is "s"
    pub key: String,

-    /// ime_key is the character inserted by the IME engine when that key was pressed.
-    /// e.g. for option-s, ime_key is "ß"
-    pub ime_key: Option<String>,
+    /// key_char is the character that could have been typed when
+    /// this binding was pressed.
+    /// e.g. for s this is "s", for option-s "ß", and cmd-s None
+    pub key_char: Option<String>,
 }

 impl Keystroke {
    /// When matching a key we cannot know whether the user intended to type
-    /// the ime_key or the key itself. On some non-US keyboards keys we use in our
+    /// the key_char or the key itself. On some non-US keyboards keys we use in our
    /// bindings are behind option (for example `$` is typed `alt-ç` on a Czech keyboard),
    /// and on some keyboards the IME handler converts a sequence of keys into a
    /// specific character (for example `"` is typed as `" space` on a brazilian keyboard).
@@ -27,17 +28,18 @@ impl Keystroke {
    /// This method assumes that `self` was typed and `target' is in the keymap, and checks
    /// both possibilities for self against the target.
    pub(crate) fn should_match(&self, target: &Keystroke) -> bool {
-        if let Some(ime_key) = self
-            .ime_key
+        if let Some(key_char) = self
+            .key_char
            .as_ref()
-            .filter(|ime_key| ime_key != &&self.key)
+            .filter(|key_char| key_char != &&self.key)
        {
            let ime_modifiers = Modifiers {
                control: self.modifiers.control,
+                platform: self.modifiers.platform,
                ..Default::default()
            };

-            if &target.key == ime_key && target.modifiers == ime_modifiers {
+            if &target.key == key_char && target.modifiers == ime_modifiers {
                return true;
            }
        }
@@ -46,9 +48,9 @@ impl Keystroke {
    }

    /// key syntax is:
-    /// [ctrl-][alt-][shift-][cmd-][fn-]key[->ime_key]
-    /// ime_key syntax is only used for generating test events,
-    /// when matching a key with an ime_key set will be matched without it.
+    /// [ctrl-][alt-][shift-][cmd-][fn-]key[->key_char]
+    /// key_char syntax is only used for generating test events,
+    /// when matching a key with an key_char set will be matched without it.
    pub fn parse(source: &str) -> anyhow::Result<Self> {
        let mut control = false;
        let mut alt = false;
@@ -56,7 +58,7 @@ impl Keystroke {
        let mut platform = false;
        let mut function = false;
        let mut key = None;
-        let mut ime_key = None;
+        let mut key_char = None;

        let mut components = source.split('-').peekable();
        while let Some(component) = components.next() {
@@ -73,7 +75,7 @@ impl Keystroke {
                            break;
                        } else if next.len() > 1 && next.starts_with('>') {
                            key = Some(String::from(component));
-                            ime_key = Some(String::from(&next[1..]));
+                            key_char = Some(String::from(&next[1..]));
                            components.next();
                        } else {
                            return Err(anyhow!("Invalid keystroke `{}`", source));
@@ -117,13 +119,16 @@ impl Keystroke {
                function,
            },
            key,
-            ime_key,
+            key_char: key_char,
        })
    }

    /// Produces a representation of this key that Parse can understand.
    pub fn unparse(&self) -> String {
        let mut str = String::new();
+        if self.modifiers.function {
+            str.push_str("fn-");
+        }
        if self.modifiers.control {
            str.push_str("ctrl-");
        }
@@ -150,7 +155,7 @@ impl Keystroke {
    /// Returns true if this keystroke left
    /// the ime system in an incomplete state.
    pub fn is_ime_in_progress(&self) -> bool {
-        self.ime_key.is_none()
+        self.key_char.is_none()
            && (is_printable_key(&self.key) || self.key.is_empty())
            && !(self.modifiers.platform
                || self.modifiers.control
@@ -158,17 +163,17 @@ impl Keystroke {
                || self.modifiers.alt)
    }

-    /// Returns a new keystroke with the ime_key filled.
+    /// Returns a new keystroke with the key_char filled.
    /// This is used for dispatch_keystroke where we want users to
    /// be able to simulate typing "space", etc.
    pub fn with_simulated_ime(mut self) -> Self {
-        if self.ime_key.is_none()
+        if self.key_char.is_none()
            && !self.modifiers.platform
            && !self.modifiers.control
            && !self.modifiers.function
            && !self.modifiers.alt
        {
-            self.ime_key = match self.key.as_str() {
+            self.key_char = match self.key.as_str() {
                "space" => Some(" ".into()),
                "tab" => Some("\t".into()),
                "enter" => Some("\n".into()),
--- a/crates/gpui/src/platform/linux/platform.rs
+++ b/crates/gpui/src/platform/linux/platform.rs
@@ -740,14 +740,14 @@ impl Keystroke {
            }
        }

-        // Ignore control characters (and DEL) for the purposes of ime_key
-        let ime_key =
+        // Ignore control characters (and DEL) for the purposes of key_char
+        let key_char =
            (key_utf32 >= 32 && key_utf32 != 127 && !key_utf8.is_empty()).then_some(key_utf8);

        Keystroke {
            modifiers,
            key,
-            ime_key,
+            key_char,
        }
    }

--- a/crates/gpui/src/platform/linux/wayland/client.rs
+++ b/crates/gpui/src/platform/linux/wayland/client.rs
@@ -1208,7 +1208,7 @@ impl Dispatch<wl_keyboard::WlKeyboard, ()> for WaylandClientStatePtr {
                            compose.feed(keysym);
                            match compose.status() {
                                xkb::Status::Composing => {
-                                    keystroke.ime_key = None;
+                                    keystroke.key_char = None;
                                    state.pre_edit_text =
                                        compose.utf8().or(Keystroke::underlying_dead_key(keysym));
                                    let pre_edit =
@@ -1220,7 +1220,7 @@ impl Dispatch<wl_keyboard::WlKeyboard, ()> for WaylandClientStatePtr {

                                xkb::Status::Composed => {
                                    state.pre_edit_text.take();
-                                    keystroke.ime_key = compose.utf8();
+                                    keystroke.key_char = compose.utf8();
                                    if let Some(keysym) = compose.keysym() {
                                        keystroke.key = xkb::keysym_get_name(keysym);
                                    }
@@ -1340,7 +1340,7 @@ impl Dispatch<zwp_text_input_v3::ZwpTextInputV3, ()> for WaylandClientStatePtr {
                            keystroke: Keystroke {
                                modifiers: Modifiers::default(),
                                key: commit_text.clone(),
-                                ime_key: Some(commit_text),
+                                key_char: Some(commit_text),
                            },
                            is_held: false,
                        }));
--- a/crates/gpui/src/platform/linux/wayland/window.rs
+++ b/crates/gpui/src/platform/linux/wayland/window.rs
@@ -687,11 +687,11 @@ impl WaylandWindowStatePtr {
            }
        }
        if let PlatformInput::KeyDown(event) = input {
-            if let Some(ime_key) = &event.keystroke.ime_key {
+            if let Some(key_char) = &event.keystroke.key_char {
                let mut state = self.state.borrow_mut();
                if let Some(mut input_handler) = state.input_handler.take() {
                    drop(state);
-                    input_handler.replace_text_in_range(None, ime_key);
+                    input_handler.replace_text_in_range(None, key_char);
                    self.state.borrow_mut().input_handler = Some(input_handler);
                }
            }
--- a/crates/gpui/src/platform/linux/x11/client.rs
+++ b/crates/gpui/src/platform/linux/x11/client.rs
@@ -178,7 +178,7 @@ pub struct X11ClientState {
    pub(crate) compose_state: Option<xkbc::compose::State>,
    pub(crate) pre_edit_text: Option<String>,
    pub(crate) composing: bool,
-    pub(crate) pre_ime_key_down: Option<Keystroke>,
+    pub(crate) pre_key_char_down: Option<Keystroke>,
    pub(crate) cursor_handle: cursor::Handle,
    pub(crate) cursor_styles: HashMap<xproto::Window, CursorStyle>,
    pub(crate) cursor_cache: HashMap<CursorStyle, xproto::Cursor>,
@@ -446,7 +446,7 @@ impl X11Client {

            compose_state,
            pre_edit_text: None,
-            pre_ime_key_down: None,
+            pre_key_char_down: None,
            composing: false,

            cursor_handle,
@@ -858,7 +858,7 @@ impl X11Client {

                let modifiers = modifiers_from_state(event.state);
                state.modifiers = modifiers;
-                state.pre_ime_key_down.take();
+                state.pre_key_char_down.take();
                let keystroke = {
                    let code = event.detail.into();
                    let xkb_state = state.previous_xkb_state.clone();
@@ -880,13 +880,13 @@ impl X11Client {
                        match compose_state.status() {
                            xkbc::Status::Composed => {
                                state.pre_edit_text.take();
-                                keystroke.ime_key = compose_state.utf8();
+                                keystroke.key_char = compose_state.utf8();
                                if let Some(keysym) = compose_state.keysym() {
                                    keystroke.key = xkbc::keysym_get_name(keysym);
                                }
                            }
                            xkbc::Status::Composing => {
-                                keystroke.ime_key = None;
+                                keystroke.key_char = None;
                                state.pre_edit_text = compose_state
                                    .utf8()
                                    .or(crate::Keystroke::underlying_dead_key(keysym));
@@ -1156,7 +1156,7 @@ impl X11Client {
        match event {
            Event::KeyPress(event) | Event::KeyRelease(event) => {
                let mut state = self.0.borrow_mut();
-                state.pre_ime_key_down = Some(Keystroke::from_xkb(
+                state.pre_key_char_down = Some(Keystroke::from_xkb(
                    &state.xkb,
                    state.modifiers,
                    event.detail.into(),
@@ -1187,11 +1187,11 @@ impl X11Client {
    fn xim_handle_commit(&self, window: xproto::Window, text: String) -> Option<()> {
        let window = self.get_window(window).unwrap();
        let mut state = self.0.borrow_mut();
-        let keystroke = state.pre_ime_key_down.take();
+        let keystroke = state.pre_key_char_down.take();
        state.composing = false;
        drop(state);
        if let Some(mut keystroke) = keystroke {
-            keystroke.ime_key = Some(text.clone());
+            keystroke.key_char = Some(text.clone());
            window.handle_input(PlatformInput::KeyDown(crate::KeyDownEvent {
                keystroke,
                is_held: false,
--- a/crates/gpui/src/platform/linux/x11/window.rs
+++ b/crates/gpui/src/platform/linux/x11/window.rs
@@ -846,9 +846,9 @@ impl X11WindowStatePtr {
        if let PlatformInput::KeyDown(event) = input {
            let mut state = self.state.borrow_mut();
            if let Some(mut input_handler) = state.input_handler.take() {
-                if let Some(ime_key) = &event.keystroke.ime_key {
+                if let Some(key_char) = &event.keystroke.key_char {
                    drop(state);
-                    input_handler.replace_text_in_range(None, ime_key);
+                    input_handler.replace_text_in_range(None, key_char);
                    state = self.state.borrow_mut();
                }
                state.input_handler = Some(input_handler);
--- a/crates/gpui/src/platform/mac/events.rs
+++ b/crates/gpui/src/platform/mac/events.rs
@@ -1,20 +1,20 @@
 use crate::{
-    platform::mac::NSStringExt, point, px, KeyDownEvent, KeyUpEvent, Keystroke, Modifiers,
-    ModifiersChangedEvent, MouseButton, MouseDownEvent, MouseExitEvent, MouseMoveEvent,
-    MouseUpEvent, NavigationDirection, Pixels, PlatformInput, ScrollDelta, ScrollWheelEvent,
-    TouchPhase,
+    platform::mac::{
+        kTISPropertyUnicodeKeyLayoutData, LMGetKbdType, NSStringExt,
+        TISCopyCurrentKeyboardLayoutInputSource, TISGetInputSourceProperty, UCKeyTranslate,
+    },
+    point, px, KeyDownEvent, KeyUpEvent, Keystroke, Modifiers, ModifiersChangedEvent, MouseButton,
+    MouseDownEvent, MouseExitEvent, MouseMoveEvent, MouseUpEvent, NavigationDirection, Pixels,
+    PlatformInput, ScrollDelta, ScrollWheelEvent, TouchPhase,
 };
 use cocoa::{
    appkit::{NSEvent, NSEventModifierFlags, NSEventPhase, NSEventType},
    base::{id, YES},
 };
-use core_graphics::{
-    event::{CGEvent, CGEventFlags, CGKeyCode},
-    event_source::{CGEventSource, CGEventSourceStateID},
-};
-use metal::foreign_types::ForeignType as _;
-use objc::{class, msg_send, sel, sel_impl};
-use std::{borrow::Cow, mem, ptr, sync::Once};
+use core_foundation::data::{CFDataGetBytePtr, CFDataRef};
+use core_graphics::event::CGKeyCode;
+use objc::{msg_send, sel, sel_impl};
+use std::{borrow::Cow, ffi::c_void};

 const BACKSPACE_KEY: u16 = 0x7f;
 const SPACE_KEY: u16 = b' ' as u16;
@@ -24,24 +24,6 @@ const ESCAPE_KEY: u16 = 0x1b;
 const TAB_KEY: u16 = 0x09;
 const SHIFT_TAB_KEY: u16 = 0x19;

-fn synthesize_keyboard_event(code: CGKeyCode) -> CGEvent {
-    static mut EVENT_SOURCE: core_graphics::sys::CGEventSourceRef = ptr::null_mut();
-    static INIT_EVENT_SOURCE: Once = Once::new();
-
-    INIT_EVENT_SOURCE.call_once(|| {
-        let source = CGEventSource::new(CGEventSourceStateID::Private).unwrap();
-        unsafe {
-            EVENT_SOURCE = source.as_ptr();
-        };
-        mem::forget(source);
-    });
-
-    let source = unsafe { core_graphics::event_source::CGEventSource::from_ptr(EVENT_SOURCE) };
-    let event = CGEvent::new_keyboard_event(source.clone(), code, true).unwrap();
-    mem::forget(source);
-    event
-}
-
 pub fn key_to_native(key: &str) -> Cow<str> {
    use cocoa::appkit::*;
    let code = match key {
@@ -259,8 +241,12 @@ impl PlatformInput {
 unsafe fn parse_keystroke(native_event: id) -> Keystroke {
    use cocoa::appkit::*;

-    let mut chars_ignoring_modifiers = chars_for_modified_key(native_event.keyCode(), false, false);
-    let first_char = chars_ignoring_modifiers.chars().next().map(|ch| ch as u16);
+    let mut characters = native_event
+        .charactersIgnoringModifiers()
+        .to_str()
+        .to_string();
+    let mut key_char = None;
+    let first_char = characters.chars().next().map(|ch| ch as u16);
    let modifiers = native_event.modifierFlags();

    let control = modifiers.contains(NSEventModifierFlags::NSControlKeyMask);
@@ -274,11 +260,20 @@ unsafe fn parse_keystroke(native_event: id) -> Keystroke {

    #[allow(non_upper_case_globals)]
    let key = match first_char {
-        Some(SPACE_KEY) => "space".to_string(),
+        Some(SPACE_KEY) => {
+            key_char = Some(" ".to_string());
+            "space".to_string()
+        }
+        Some(TAB_KEY) => {
+            key_char = Some("\t".to_string());
+            "tab".to_string()
+        }
+        Some(ENTER_KEY) | Some(NUMPAD_ENTER_KEY) => {
+            key_char = Some("\n".to_string());
+            "enter".to_string()
+        }
        Some(BACKSPACE_KEY) => "backspace".to_string(),
-        Some(ENTER_KEY) | Some(NUMPAD_ENTER_KEY) => "enter".to_string(),
        Some(ESCAPE_KEY) => "escape".to_string(),
-        Some(TAB_KEY) => "tab".to_string(),
        Some(SHIFT_TAB_KEY) => "tab".to_string(),
        Some(NSUpArrowFunctionKey) => "up".to_string(),
        Some(NSDownArrowFunctionKey) => "down".to_string(),
@@ -313,7 +308,7 @@ unsafe fn parse_keystroke(native_event: id) -> Keystroke {
        _ => {
            // Cases to test when modifying this:
            //
-            //          qwerty key | none | cmd   | cmd-shift
+            //           qwerty key | none | cmd   | cmd-shift
            // * Armenian         s | ս    | cmd-s | cmd-shift-s  (layout is non-ASCII, so we use cmd layout)
            // * Dvorak+QWERTY    s | o    | cmd-s | cmd-shift-s  (layout switches on cmd)
            // * Ukrainian+QWERTY s | с    | cmd-s | cmd-shift-s  (macOS reports cmd-s instead of cmd-S)
@@ -321,12 +316,17 @@ unsafe fn parse_keystroke(native_event: id) -> Keystroke {
            // * Norwegian        7 | 7    | cmd-7 | cmd-/        (macOS reports cmd-shift-7 instead of cmd-/)
            // * Russian          7 | 7    | cmd-7 | cmd-&        (shift-7 is . but when cmd is down, should use cmd layout)
            // * German QWERTZ    ; | ö    | cmd-ö | cmd-Ö        (Zed's shift special case only applies to a-z)
-            let mut chars_with_shift = chars_for_modified_key(native_event.keyCode(), false, true);
+            //
+            let mut chars_ignoring_modifiers =
+                chars_for_modified_key(native_event.keyCode(), NO_MOD);
+            let mut chars_with_shift = chars_for_modified_key(native_event.keyCode(), SHIFT_MOD);
+            let always_use_cmd_layout = always_use_command_layout();

            // Handle Dvorak+QWERTY / Russian / Armeniam
-            if command || always_use_command_layout() {
-                let chars_with_cmd = chars_for_modified_key(native_event.keyCode(), true, false);
-                let chars_with_both = chars_for_modified_key(native_event.keyCode(), true, true);
+            if command || always_use_cmd_layout {
+                let chars_with_cmd = chars_for_modified_key(native_event.keyCode(), CMD_MOD);
+                let chars_with_both =
+                    chars_for_modified_key(native_event.keyCode(), CMD_MOD | SHIFT_MOD);

                // We don't do this in the case that the shifted command key generates
                // the same character as the unshifted command key (Norwegian, e.g.)
@@ -341,14 +341,32 @@ unsafe fn parse_keystroke(native_event: id) -> Keystroke {
                chars_ignoring_modifiers = chars_with_cmd;
            }

-            if shift && chars_ignoring_modifiers == chars_with_shift.to_ascii_lowercase() {
+            if !control && !command && !function {
+                let mut mods = NO_MOD;
+                if shift {
+                    mods |= SHIFT_MOD;
+                }
+                if alt {
+                    mods |= OPTION_MOD;
+                }
+
+                key_char = Some(chars_for_modified_key(native_event.keyCode(), mods));
+            }
+
+            let mut key = if shift
+                && chars_ignoring_modifiers
+                    .chars()
+                    .all(|c| c.is_ascii_lowercase())
+            {
                chars_ignoring_modifiers
            } else if shift {
                shift = false;
                chars_with_shift
            } else {
                chars_ignoring_modifiers
-            }
+            };
+
+            key
        }
    };

@@ -361,50 +379,83 @@ unsafe fn parse_keystroke(native_event: id) -> Keystroke {
            function,
        },
        key,
-        ime_key: None,
+        key_char,
    }
 }

 fn always_use_command_layout() -> bool {
-    // look at the key to the right of "tab" ('a' in QWERTY)
-    // if it produces a non-ASCII character, but with command held produces ASCII,
-    // we default to the command layout for our keyboard system.
-    let event = synthesize_keyboard_event(0);
-    let without_cmd = unsafe {
-        let event: id = msg_send![class!(NSEvent), eventWithCGEvent: &*event];
-        event.characters().to_str().to_string()
-    };
-    if without_cmd.is_ascii() {
+    if chars_for_modified_key(0, NO_MOD).is_ascii() {
        return false;
    }

-    event.set_flags(CGEventFlags::CGEventFlagCommand);
-    let with_cmd = unsafe {
-        let event: id = msg_send![class!(NSEvent), eventWithCGEvent: &*event];
-        event.characters().to_str().to_string()
-    };
-
-    with_cmd.is_ascii()
+    chars_for_modified_key(0, CMD_MOD).is_ascii()
 }

-fn chars_for_modified_key(code: CGKeyCode, cmd: bool, shift: bool) -> String {
-    // Ideally, we would use `[NSEvent charactersByApplyingModifiers]` but that
-    // always returns an empty string with certain keyboards, e.g. Japanese. Synthesizing
-    // an event with the given flags instead lets us access `characters`, which always
-    // returns a valid string.
-    let event = synthesize_keyboard_event(code);
+const NO_MOD: u32 = 0;
+const CMD_MOD: u32 = 1;
+const SHIFT_MOD: u32 = 2;
+const OPTION_MOD: u32 = 8;

-    let mut flags = CGEventFlags::empty();
-    if cmd {
-        flags |= CGEventFlags::CGEventFlagCommand;
+fn chars_for_modified_key(code: CGKeyCode, modifiers: u32) -> String {
+    // Values from: https://github.com/phracker/MacOSX-SDKs/blob/master/MacOSX10.6.sdk/System/Library/Frameworks/Carbon.framework/Versions/A/Frameworks/HIToolbox.framework/Versions/A/Headers/Events.h#L126
+    // shifted >> 8 for UCKeyTranslate
+    const CG_SPACE_KEY: u16 = 49;
+    // https://github.com/phracker/MacOSX-SDKs/blob/master/MacOSX10.6.sdk/System/Library/Frameworks/CoreServices.framework/Versions/A/Frameworks/CarbonCore.framework/Versions/A/Headers/UnicodeUtilities.h#L278
+    #[allow(non_upper_case_globals)]
+    const kUCKeyActionDown: u16 = 0;
+    #[allow(non_upper_case_globals)]
+    const kUCKeyTranslateNoDeadKeysMask: u32 = 0;
+
+    let keyboard_type = unsafe { LMGetKbdType() as u32 };
+    const BUFFER_SIZE: usize = 4;
+    let mut dead_key_state = 0;
+    let mut buffer: [u16; BUFFER_SIZE] = [0; BUFFER_SIZE];
+    let mut buffer_size: usize = 0;
+
+    let keyboard = unsafe { TISCopyCurrentKeyboardLayoutInputSource() };
+    if keyboard.is_null() {
+        return "".to_string();
    }
-    if shift {
-        flags |= CGEventFlags::CGEventFlagShift;
+    let layout_data = unsafe {
+        TISGetInputSourceProperty(keyboard, kTISPropertyUnicodeKeyLayoutData as *const c_void)
+            as CFDataRef
+    };
+    if layout_data.is_null() {
+        unsafe {
+            let _: () = msg_send![keyboard, release];
+        }
+        return "".to_string();
    }
-    event.set_flags(flags);
+    let keyboard_layout = unsafe { CFDataGetBytePtr(layout_data) };

    unsafe {
-        let event: id = msg_send![class!(NSEvent), eventWithCGEvent: &*event];
-        event.characters().to_str().to_string()
+        UCKeyTranslate(
+            keyboard_layout as *const c_void,
+            code,
+            kUCKeyActionDown,
+            modifiers,
+            keyboard_type,
+            kUCKeyTranslateNoDeadKeysMask,
+            &mut dead_key_state,
+            BUFFER_SIZE,
+            &mut buffer_size as *mut usize,
+            &mut buffer as *mut u16,
+        );
+        if dead_key_state != 0 {
+            UCKeyTranslate(
+                keyboard_layout as *const c_void,
+                CG_SPACE_KEY,
+                kUCKeyActionDown,
+                modifiers,
+                keyboard_type,
+                kUCKeyTranslateNoDeadKeysMask,
+                &mut dead_key_state,
+                BUFFER_SIZE,
+                &mut buffer_size as *mut usize,
+                &mut buffer as *mut u16,
+            );
+        }
+        let _: () = msg_send![keyboard, release];
    }
+    String::from_utf16(&buffer[..buffer_size]).unwrap_or_default()
 }
--- a/crates/gpui/src/platform/mac/platform.rs
+++ b/crates/gpui/src/platform/mac/platform.rs
@@ -19,7 +19,7 @@ use cocoa::{
        NSPasteboardTypePNG, NSPasteboardTypeRTF, NSPasteboardTypeRTFD, NSPasteboardTypeString,
        NSPasteboardTypeTIFF, NSSavePanel, NSWindow,
    },
-    base::{id, nil, selector, BOOL, YES},
+    base::{id, nil, selector, BOOL, NO, YES},
    foundation::{
        NSArray, NSAutoreleasePool, NSBundle, NSData, NSInteger, NSProcessInfo, NSRange, NSString,
        NSUInteger, NSURL,
@@ -343,6 +343,10 @@ impl MacPlatform {
                                ns_string(key_to_native(&keystroke.key).as_ref()),
                            )
                            .autorelease();
+                        if MacPlatform::os_version().unwrap() >= SemanticVersion::new(12, 0, 0) {
+                            let _: () =
+                                msg_send![item, setAllowsAutomaticKeyEquivalentLocalization: NO];
+                        }
                        item.setKeyEquivalentModifierMask_(mask);
                    }
                    // For multi-keystroke bindings, render the keystroke as part of the title.
@@ -840,7 +844,9 @@ impl Platform for MacPlatform {
            let app: id = msg_send![APP_CLASS, sharedApplication];
            let mut state = self.0.lock();
            let actions = &mut state.menu_actions;
-            app.setMainMenu_(self.create_menu_bar(menus, NSWindow::delegate(app), actions, keymap));
+            let menu = self.create_menu_bar(menus, NSWindow::delegate(app), actions, keymap);
+            drop(state);
+            app.setMainMenu_(menu);
        }
    }

@@ -1448,13 +1454,27 @@ unsafe fn ns_url_to_path(url: id) -> Result<PathBuf> {

 #[link(name = "Carbon", kind = "framework")]
 extern "C" {
-    fn TISCopyCurrentKeyboardLayoutInputSource() -> *mut Object;
-    fn TISGetInputSourceProperty(
+    pub(super) fn TISCopyCurrentKeyboardLayoutInputSource() -> *mut Object;
+    pub(super) fn TISGetInputSourceProperty(
        inputSource: *mut Object,
        propertyKey: *const c_void,
    ) -> *mut Object;

-    pub static kTISPropertyInputSourceID: CFStringRef;
+    pub(super) fn UCKeyTranslate(
+        keyLayoutPtr: *const ::std::os::raw::c_void,
+        virtualKeyCode: u16,
+        keyAction: u16,
+        modifierKeyState: u32,
+        keyboardType: u32,
+        keyTranslateOptions: u32,
+        deadKeyState: *mut u32,
+        maxStringLength: usize,
+        actualStringLength: *mut usize,
+        unicodeString: *mut u16,
+    ) -> u32;
+    pub(super) fn LMGetKbdType() -> u16;
+    pub(super) static kTISPropertyUnicodeKeyLayoutData: CFStringRef;
+    pub(super) static kTISPropertyInputSourceID: CFStringRef;
 }

 mod security {
--- a/crates/gpui/src/platform/mac/window.rs
+++ b/crates/gpui/src/platform/mac/window.rs
@@ -38,7 +38,6 @@ use std::{
    cell::Cell,
    ffi::{c_void, CStr},
    mem,
-    ops::Range,
    path::PathBuf,
    ptr::{self, NonNull},
    rc::Rc,
@@ -310,14 +309,6 @@ unsafe fn build_window_class(name: &'static str, superclass: &Class) -> *const C
    decl.register()
 }

-#[allow(clippy::enum_variant_names)]
-#[derive(Clone, Debug)]
-enum ImeInput {
-    InsertText(String, Option<Range<usize>>),
-    SetMarkedText(String, Option<Range<usize>>, Option<Range<usize>>),
-    UnmarkText,
-}
-
 struct MacWindowState {
    handle: AnyWindowHandle,
    executor: ForegroundExecutor,
@@ -338,14 +329,11 @@ struct MacWindowState {
    synthetic_drag_counter: usize,
    traffic_light_position: Option<Point<Pixels>>,
    previous_modifiers_changed_event: Option<PlatformInput>,
-    // State tracking what the IME did after the last request
-    last_ime_inputs: Option<SmallVec<[(String, Option<Range<usize>>); 1]>>,
-    previous_keydown_inserted_text: Option<String>,
+    keystroke_for_do_command: Option<Keystroke>,
    external_files_dragged: bool,
    // Whether the next left-mouse click is also the focusing click.
    first_mouse: bool,
    fullscreen_restore_bounds: Bounds<Pixels>,
-    ime_composing: bool,
 }

 impl MacWindowState {
@@ -619,12 +607,10 @@ impl MacWindow {
                    .as_ref()
                    .and_then(|titlebar| titlebar.traffic_light_position),
                previous_modifiers_changed_event: None,
-                last_ime_inputs: None,
-                previous_keydown_inserted_text: None,
+                keystroke_for_do_command: None,
                external_files_dragged: false,
                first_mouse: false,
                fullscreen_restore_bounds: Bounds::default(),
-                ime_composing: false,
            })));

            (*native_window).set_ivar(
@@ -1226,9 +1212,9 @@ extern "C" fn handle_key_down(this: &Object, _: Sel, native_event: id) {
 //  Brazilian layout:
 //   - `" space` should create an unmarked quote
 //   - `" backspace` should delete the marked quote
+//   - `" "`should create an unmarked quote and a second marked quote
 //   - `" up` should insert a quote, unmark it, and move up one line
 //   - `" cmd-down` should insert a quote, unmark it, and move to the end of the file
-//      - NOTE: The current implementation does not move the selection to the end of the file
 //   - `cmd-ctrl-space` and clicking on an emoji should type it
 //  Czech (QWERTY) layout:
 //   - in vim mode `option-4`  should go to end of line (same as $)
@@ -1241,95 +1227,85 @@ extern "C" fn handle_key_event(this: &Object, native_event: id, key_equivalent:
    let window_height = lock.content_size().height;
    let event = unsafe { PlatformInput::from_native(native_event, Some(window_height)) };

-    if let Some(PlatformInput::KeyDown(mut event)) = event {
-        // For certain keystrokes, macOS will first dispatch a "key equivalent" event.
-        // If that event isn't handled, it will then dispatch a "key down" event. GPUI
-        // makes no distinction between these two types of events, so we need to ignore
-        // the "key down" event if we've already just processed its "key equivalent" version.
-        if key_equivalent {
-            lock.last_key_equivalent = Some(event.clone());
-        } else if lock.last_key_equivalent.take().as_ref() == Some(&event) {
-            return NO;
+    let Some(PlatformInput::KeyDown(mut event)) = event else {
+        return NO;
+    };
+    // For certain keystrokes, macOS will first dispatch a "key equivalent" event.
+    // If that event isn't handled, it will then dispatch a "key down" event. GPUI
+    // makes no distinction between these two types of events, so we need to ignore
+    // the "key down" event if we've already just processed its "key equivalent" version.
+    if key_equivalent {
+        lock.last_key_equivalent = Some(event.clone());
+    } else if lock.last_key_equivalent.take().as_ref() == Some(&event) {
+        return NO;
+    }
+
+    drop(lock);
+
+    let is_composing = with_input_handler(this, |input_handler| input_handler.marked_text_range())
+        .flatten()
+        .is_some();
+
+    // If we're composing, send the key to the input handler first;
+    // otherwise we only send to the input handler if we don't have a matching binding.
+    // The input handler may call `do_command_by_selector` if it doesn't know how to handle
+    // a key. If it does so, it will return YES so we won't send the key twice.
+    if is_composing || event.keystroke.key.is_empty() {
+        window_state.as_ref().lock().keystroke_for_do_command = Some(event.keystroke.clone());
+        let handled: BOOL = unsafe {
+            let input_context: id = msg_send![this, inputContext];
+            msg_send![input_context, handleEvent: native_event]
+        };
+        window_state.as_ref().lock().keystroke_for_do_command.take();
+        if handled == YES {
+            return YES;
        }

-        let keydown = event.keystroke.clone();
-        let fn_modifier = keydown.modifiers.function;
-        lock.last_ime_inputs = Some(Default::default());
-        drop(lock);
+        let mut callback = window_state.as_ref().lock().event_callback.take();
+        let handled: BOOL = if let Some(callback) = callback.as_mut() {
+            !callback(PlatformInput::KeyDown(event)).propagate as BOOL
+        } else {
+            NO
+        };
+        window_state.as_ref().lock().event_callback = callback;
+        return handled as BOOL;
+    }

-        // Send the event to the input context for IME handling, unless the `fn` modifier is
-        // being pressed.
-        // this will call back into `insert_text`, etc.
-        if !fn_modifier {
-            unsafe {
-                let input_context: id = msg_send![this, inputContext];
-                let _: BOOL = msg_send![input_context, handleEvent: native_event];
-            }
-        }
-
-        let mut handled = false;
-        let mut lock = window_state.lock();
-        let previous_keydown_inserted_text = lock.previous_keydown_inserted_text.take();
-        let mut last_inserts = lock.last_ime_inputs.take().unwrap();
-        let ime_composing = std::mem::take(&mut lock.ime_composing);
-
-        let mut callback = lock.event_callback.take();
-        drop(lock);
-
-        let last_insert = last_inserts.pop();
-        // on a brazilian keyboard typing `"` and then hitting `up` will cause two IME
-        // events, one to unmark the quote, and one to send the up arrow.
-        for (text, range) in last_inserts {
-            send_to_input_handler(this, ImeInput::InsertText(text, range));
-        }
-
-        let is_composing =
-            with_input_handler(this, |input_handler| input_handler.marked_text_range())
-                .flatten()
-                .is_some()
-                || ime_composing;
-
-        if let Some((text, range)) = last_insert {
-            if !is_composing {
-                window_state.lock().previous_keydown_inserted_text = Some(text.clone());
-                if let Some(callback) = callback.as_mut() {
-                    event.keystroke.ime_key = Some(text.clone());
-                    handled = !callback(PlatformInput::KeyDown(event)).propagate;
-                }
-            }
-
-            if !handled {
-                handled = true;
-                send_to_input_handler(this, ImeInput::InsertText(text, range));
-            }
-        } else if !is_composing {
-            let is_held = event.is_held;
-
-            if let Some(callback) = callback.as_mut() {
-                handled = !callback(PlatformInput::KeyDown(event)).propagate;
-            }
-
-            if !handled && is_held {
-                if let Some(text) = previous_keydown_inserted_text {
-                    // macOS IME is a bit funky, and even when you've told it there's nothing to
-                    // enter it will still swallow certain keys (e.g. 'f', 'j') and not others
-                    // (e.g. 'n'). This is a problem for certain kinds of views, like the terminal.
-                    with_input_handler(this, |input_handler| {
-                        if input_handler.selected_text_range(false).is_none() {
-                            handled = true;
-                            input_handler.replace_text_in_range(None, &text)
-                        }
-                    });
-                    window_state.lock().previous_keydown_inserted_text = Some(text);
-                }
-            }
-        }
-
-        window_state.lock().event_callback = callback;
-
-        handled as BOOL
+    let mut callback = window_state.as_ref().lock().event_callback.take();
+    let handled = if let Some(callback) = callback.as_mut() {
+        !callback(PlatformInput::KeyDown(event.clone())).propagate as BOOL
    } else {
        NO
+    };
+    window_state.as_ref().lock().event_callback = callback;
+    if handled == YES {
+        return YES;
+    }
+
+    if event.is_held {
+        if let Some(key_char) = event.keystroke.key_char.as_ref() {
+            let handled = with_input_handler(&this, |input_handler| {
+                if !input_handler.apple_press_and_hold_enabled() {
+                    input_handler.replace_text_in_range(None, &key_char);
+                    return YES;
+                }
+                NO
+            });
+            if handled == Some(YES) {
+                return YES;
+            }
+        }
+    }
+
+    // Don't send key equivalents to the input handler,
+    // or macOS shortcuts like cmd-` will stop working.
+    if key_equivalent {
+        return NO;
+    }
+
+    unsafe {
+        let input_context: id = msg_send![this, inputContext];
+        msg_send![input_context, handleEvent: native_event]
    }
 }

@@ -1460,7 +1436,7 @@ extern "C" fn cancel_operation(this: &Object, _sel: Sel, _sender: id) {
    let keystroke = Keystroke {
        modifiers: Default::default(),
        key: ".".into(),
-        ime_key: None,
+        key_char: None,
    };
    let event = PlatformInput::KeyDown(KeyDownEvent {
        keystroke: keystroke.clone(),
@@ -1741,10 +1717,9 @@ extern "C" fn insert_text(this: &Object, _: Sel, text: id, replacement_range: NS

        let text = text.to_str();
        let replacement_range = replacement_range.to_range();
-        send_to_input_handler(
-            this,
-            ImeInput::InsertText(text.to_string(), replacement_range),
-        );
+        with_input_handler(this, |input_handler| {
+            input_handler.replace_text_in_range(replacement_range, &text)
+        });
    }
 }

@@ -1766,15 +1741,13 @@ extern "C" fn set_marked_text(
        let selected_range = selected_range.to_range();
        let replacement_range = replacement_range.to_range();
        let text = text.to_str();
-
-        send_to_input_handler(
-            this,
-            ImeInput::SetMarkedText(text.to_string(), replacement_range, selected_range),
-        );
+        with_input_handler(this, |input_handler| {
+            input_handler.replace_and_mark_text_in_range(replacement_range, &text, selected_range)
+        });
    }
 }
 extern "C" fn unmark_text(this: &Object, _: Sel) {
-    send_to_input_handler(this, ImeInput::UnmarkText);
+    with_input_handler(this, |input_handler| input_handler.unmark_text());
 }

 extern "C" fn attributed_substring_for_proposed_range(
@@ -1800,7 +1773,24 @@ extern "C" fn attributed_substring_for_proposed_range(
    .unwrap_or(nil)
 }

-extern "C" fn do_command_by_selector(_: &Object, _: Sel, _: Sel) {}
+// We ignore which selector it asks us to do because the user may have
+// bound the shortcut to something else.
+extern "C" fn do_command_by_selector(this: &Object, _: Sel, _: Sel) {
+    let state = unsafe { get_window_state(this) };
+    let mut lock = state.as_ref().lock();
+    let keystroke = lock.keystroke_for_do_command.take();
+    let mut event_callback = lock.event_callback.take();
+    drop(lock);
+
+    if let Some((keystroke, mut callback)) = keystroke.zip(event_callback.as_mut()) {
+        (callback)(PlatformInput::KeyDown(KeyDownEvent {
+            keystroke,
+            is_held: false,
+        }));
+    }
+
+    state.as_ref().lock().event_callback = event_callback;
+}

 extern "C" fn view_did_change_effective_appearance(this: &Object, _: Sel) {
    unsafe {
@@ -1950,43 +1940,6 @@ where
    }
 }

-fn send_to_input_handler(window: &Object, ime: ImeInput) {
-    unsafe {
-        let window_state = get_window_state(window);
-        let mut lock = window_state.lock();
-
-        if let Some(mut input_handler) = lock.input_handler.take() {
-            match ime {
-                ImeInput::InsertText(text, range) => {
-                    if let Some(ime_input) = lock.last_ime_inputs.as_mut() {
-                        ime_input.push((text, range));
-                        lock.input_handler = Some(input_handler);
-                        return;
-                    }
-                    drop(lock);
-                    input_handler.replace_text_in_range(range, &text)
-                }
-                ImeInput::SetMarkedText(text, range, marked_range) => {
-                    lock.ime_composing = true;
-                    drop(lock);
-                    input_handler.replace_and_mark_text_in_range(range, &text, marked_range)
-                }
-                ImeInput::UnmarkText => {
-                    drop(lock);
-                    input_handler.unmark_text()
-                }
-            }
-            window_state.lock().input_handler = Some(input_handler);
-        } else {
-            if let ImeInput::InsertText(text, range) = ime {
-                if let Some(ime_input) = lock.last_ime_inputs.as_mut() {
-                    ime_input.push((text, range));
-                }
-            }
-        }
-    }
-}
-
 unsafe fn display_id_for_screen(screen: id) -> CGDirectDisplayID {
    let device_description = NSScreen::deviceDescription(screen);
    let screen_number_key: id = NSString::alloc(nil).init_str("NSScreenNumber");
--- a/crates/gpui/src/platform/windows/events.rs
+++ b/crates/gpui/src/platform/windows/events.rs
@@ -386,7 +386,7 @@ fn handle_char_msg(
        return Some(1);
    };
    drop(lock);
-    let ime_key = keystroke.ime_key.clone();
+    let key_char = keystroke.key_char.clone();
    let event = KeyDownEvent {
        keystroke,
        is_held: lparam.0 & (0x1 << 30) > 0,
@@ -397,7 +397,7 @@ fn handle_char_msg(
    if dispatch_event_result.default_prevented || !dispatch_event_result.propagate {
        return Some(0);
    }
-    let Some(ime_char) = ime_key else {
+    let Some(ime_char) = key_char else {
        return Some(1);
    };
    with_input_handler(&state_ptr, |input_handler| {
@@ -1170,7 +1170,7 @@ fn parse_syskeydown_msg_keystroke(wparam: WPARAM) -> Option<Keystroke> {
    Some(Keystroke {
        modifiers,
        key,
-        ime_key: None,
+        key_char: None,
    })
 }

@@ -1216,7 +1216,7 @@ fn parse_keydown_msg_keystroke(wparam: WPARAM) -> Option<KeystrokeOrModifier> {
                return Some(KeystrokeOrModifier::Keystroke(Keystroke {
                    modifiers,
                    key: format!("f{}", offset + 1),
-                    ime_key: None,
+                    key_char: None,
                }));
            };
            return None;
@@ -1227,7 +1227,7 @@ fn parse_keydown_msg_keystroke(wparam: WPARAM) -> Option<KeystrokeOrModifier> {
    Some(KeystrokeOrModifier::Keystroke(Keystroke {
        modifiers,
        key,
-        ime_key: None,
+        key_char: None,
    }))
 }

@@ -1249,7 +1249,7 @@ fn parse_char_msg_keystroke(wparam: WPARAM) -> Option<Keystroke> {
        Some(Keystroke {
            modifiers,
            key,
-            ime_key: Some(first_char.to_string()),
+            key_char: Some(first_char.to_string()),
        })
    }
 }
@@ -1323,7 +1323,7 @@ fn basic_vkcode_to_string(code: u16, modifiers: Modifiers) -> Option<Keystroke>
    Some(Keystroke {
        modifiers,
        key,
-        ime_key: None,
+        key_char: None,
    })
 }

--- a/crates/gpui/src/window.rs
+++ b/crates/gpui/src/window.rs
@@ -3043,7 +3043,7 @@ impl<'a> WindowContext<'a> {
            return true;
        }

-        if let Some(input) = keystroke.ime_key {
+        if let Some(input) = keystroke.key_char {
            if let Some(mut input_handler) = self.window.platform_window.take_input_handler() {
                input_handler.dispatch_input(&input, self);
                self.window.platform_window.set_input_handler(input_handler);
@@ -3252,7 +3252,7 @@ impl<'a> WindowContext<'a> {
                if let Some(key) = key {
                    keystroke = Some(Keystroke {
                        key: key.to_string(),
-                        ime_key: None,
+                        key_char: None,
                        modifiers: Modifiers::default(),
                    });
                }
@@ -3467,7 +3467,7 @@ impl<'a> WindowContext<'a> {
            if !self.propagate_event {
                continue 'replay;
            }
-            if let Some(input) = replay.keystroke.ime_key.as_ref().cloned() {
+            if let Some(input) = replay.keystroke.key_char.as_ref().cloned() {
                if let Some(mut input_handler) = self.window.platform_window.take_input_handler() {
                    input_handler.dispatch_input(&input, self);
                    self.window.platform_window.set_input_handler(input_handler)
--- a/crates/http_client/src/github.rs
+++ b/crates/http_client/src/github.rs
@@ -121,6 +121,7 @@ pub async fn get_release_by_tag_name(
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]
 pub enum AssetKind {
    TarGz,
+    Gz,
    Zip,
 }

@@ -134,6 +135,7 @@ pub fn build_asset_url(repo_name_with_owner: &str, tag: &str, kind: AssetKind) -
        "{tag}.{extension}",
        extension = match kind {
            AssetKind::TarGz => "tar.gz",
+            AssetKind::Gz => "gz",
            AssetKind::Zip => "zip",
        }
    );
--- a/crates/languages/src/rust.rs
+++ b/crates/languages/src/rust.rs
@@ -26,13 +26,13 @@ pub struct RustLspAdapter;

 #[cfg(target_os = "macos")]
 impl RustLspAdapter {
-    const GITHUB_ASSET_KIND: AssetKind = AssetKind::TarGz;
+    const GITHUB_ASSET_KIND: AssetKind = AssetKind::Gz;
    const ARCH_SERVER_NAME: &str = "apple-darwin";
 }

 #[cfg(target_os = "linux")]
 impl RustLspAdapter {
-    const GITHUB_ASSET_KIND: AssetKind = AssetKind::TarGz;
+    const GITHUB_ASSET_KIND: AssetKind = AssetKind::Gz;
    const ARCH_SERVER_NAME: &str = "unknown-linux-gnu";
 }

@@ -47,7 +47,8 @@ impl RustLspAdapter {

    fn build_asset_name() -> String {
        let extension = match Self::GITHUB_ASSET_KIND {
-            AssetKind::TarGz => "gz", // Nb: rust-analyzer releases use .gz not .tar.gz
+            AssetKind::TarGz => "tar.gz",
+            AssetKind::Gz => "gz",
            AssetKind::Zip => "zip",
        };

@@ -134,7 +135,7 @@ impl LspAdapter for RustLspAdapter {
        let version = version.downcast::<GitHubLspBinaryVersion>().unwrap();
        let destination_path = container_dir.join(format!("rust-analyzer-{}", version.name));
        let server_path = match Self::GITHUB_ASSET_KIND {
-            AssetKind::TarGz => destination_path.clone(), // Tar extracts in place.
+            AssetKind::TarGz | AssetKind::Gz => destination_path.clone(), // Tar and gzip extract in place.
            AssetKind::Zip => destination_path.clone().join("rust-analyzer.exe"), // zip contains a .exe
        };

@@ -145,19 +146,40 @@ impl LspAdapter for RustLspAdapter {
                .http_client()
                .get(&version.url, Default::default(), true)
                .await
-                .map_err(|err| anyhow!("error downloading release: {}", err))?;
+                .with_context(|| format!("downloading release from {}", version.url))?;
            match Self::GITHUB_ASSET_KIND {
                AssetKind::TarGz => {
                    let decompressed_bytes = GzipDecoder::new(BufReader::new(response.body_mut()));
                    let archive = async_tar::Archive::new(decompressed_bytes);
-                    archive.unpack(&destination_path).await?;
+                    archive.unpack(&destination_path).await.with_context(|| {
+                        format!("extracting {} to {:?}", version.url, destination_path)
+                    })?;
+                }
+                AssetKind::Gz => {
+                    let mut decompressed_bytes =
+                        GzipDecoder::new(BufReader::new(response.body_mut()));
+                    let mut file =
+                        fs::File::create(&destination_path).await.with_context(|| {
+                            format!(
+                                "creating a file {:?} for a download from {}",
+                                destination_path, version.url,
+                            )
+                        })?;
+                    futures::io::copy(&mut decompressed_bytes, &mut file)
+                        .await
+                        .with_context(|| {
+                            format!("extracting {} to {:?}", version.url, destination_path)
+                        })?;
                }
                AssetKind::Zip => {
                    node_runtime::extract_zip(
                        &destination_path,
                        BufReader::new(response.body_mut()),
                    )
-                    .await?;
+                    .await
+                    .with_context(|| {
+                        format!("unzipping {} to {:?}", version.url, destination_path)
+                    })?;
                }
            };

--- a/crates/languages/src/typescript.rs
+++ b/crates/languages/src/typescript.rs
@@ -1,4 +1,4 @@
-use anyhow::{anyhow, Result};
+use anyhow::{anyhow, Context as _, Result};
 use async_compression::futures::bufread::GzipDecoder;
 use async_tar::Archive;
 use async_trait::async_trait;
@@ -445,14 +445,35 @@ impl LspAdapter for EsLintLspAdapter {
                AssetKind::TarGz => {
                    let decompressed_bytes = GzipDecoder::new(BufReader::new(response.body_mut()));
                    let archive = Archive::new(decompressed_bytes);
-                    archive.unpack(&destination_path).await?;
+                    archive.unpack(&destination_path).await.with_context(|| {
+                        format!("extracting {} to {:?}", version.url, destination_path)
+                    })?;
+                }
+                AssetKind::Gz => {
+                    let mut decompressed_bytes =
+                        GzipDecoder::new(BufReader::new(response.body_mut()));
+                    let mut file =
+                        fs::File::create(&destination_path).await.with_context(|| {
+                            format!(
+                                "creating a file {:?} for a download from {}",
+                                destination_path, version.url,
+                            )
+                        })?;
+                    futures::io::copy(&mut decompressed_bytes, &mut file)
+                        .await
+                        .with_context(|| {
+                            format!("extracting {} to {:?}", version.url, destination_path)
+                        })?;
                }
                AssetKind::Zip => {
                    node_runtime::extract_zip(
                        &destination_path,
                        BufReader::new(response.body_mut()),
                    )
-                    .await?;
+                    .await
+                    .with_context(|| {
+                        format!("unzipping {} to {:?}", version.url, destination_path)
+                    })?;
                }
            }

--- a/crates/markdown_preview/src/markdown_renderer.rs
+++ b/crates/markdown_preview/src/markdown_renderer.rs
@@ -206,7 +206,7 @@ fn render_markdown_list_item(
                let secondary_modifier = Keystroke {
                    key: "".to_string(),
                    modifiers: Modifiers::secondary_key(),
-                    ime_key: None,
+                    key_char: None,
                };
                Tooltip::text(
                    format!("{}-click to toggle the checkbox", secondary_modifier),
--- a/crates/repl/src/outputs/image.rs
+++ b/crates/repl/src/outputs/image.rs
@@ -1,5 +1,9 @@
 use anyhow::Result;
-use base64::prelude::*;
+use base64::{
+    alphabet,
+    engine::{DecodePaddingMode, GeneralPurpose, GeneralPurposeConfig},
+    Engine as _,
+};
 use gpui::{img, ClipboardItem, Image, ImageFormat, Pixels, RenderImage, WindowContext};
 use std::sync::Arc;
 use ui::{div, prelude::*, IntoElement, Styled};
@@ -14,11 +18,18 @@ pub struct ImageView {
    image: Arc<RenderImage>,
 }

+pub const STANDARD_INDIFFERENT: GeneralPurpose = GeneralPurpose::new(
+    &alphabet::STANDARD,
+    GeneralPurposeConfig::new()
+        .with_encode_padding(false)
+        .with_decode_padding_mode(DecodePaddingMode::Indifferent),
+);
+
 impl ImageView {
    pub fn from(base64_encoded_data: &str) -> Result<Self> {
        let filtered =
            base64_encoded_data.replace(&[' ', '\n', '\t', '\r', '\x0b', '\x0c'][..], "");
-        let bytes = BASE64_STANDARD_NO_PAD.decode(filtered)?;
+        let bytes = STANDARD_INDIFFERENT.decode(filtered)?;

        let format = image::guess_format(&bytes)?;

--- a/crates/settings/src/key_equivalents.rs
+++ b/crates/settings/src/key_equivalents.rs
--- a/crates/terminal/src/mappings/keys.rs
+++ b/crates/terminal/src/mappings/keys.rs
@@ -343,7 +343,7 @@ mod test {
                function: false,
            },
            key: "🖖🏻".to_string(), //2 char string
-            ime_key: None,
+            key_char: None,
        };
        assert_eq!(to_esc_str(&ks, &TermMode::NONE, false), None);
    }
--- a/crates/terminal_view/src/terminal_element.rs
+++ b/crates/terminal_view/src/terminal_element.rs
@@ -1044,6 +1044,10 @@ impl InputHandler for TerminalInputHandler {
    ) -> Option<Bounds<Pixels>> {
        self.cursor_bounds
    }
+
+    fn apple_press_and_hold_enabled(&mut self) -> bool {
+        false
+    }
 }

 pub fn is_blank(cell: &IndexedCell) -> bool {
--- a/crates/vim/src/digraph.rs
+++ b/crates/vim/src/digraph.rs
@@ -83,7 +83,7 @@ impl Vim {
        cx: &mut ViewContext<Self>,
    ) {
        // handled by handle_literal_input
-        if keystroke_event.keystroke.ime_key.is_some() {
+        if keystroke_event.keystroke.key_char.is_some() {
            return;
        };

--- a/crates/zed/Cargo.toml
+++ b/crates/zed/Cargo.toml
@@ -2,7 +2,7 @@
 description = "The fast, collaborative code editor."
 edition = "2021"
 name = "zed"
-version = "0.162.0"
+version = "0.162.4"
 publish = false
 license = "GPL-3.0-or-later"
 authors = ["Zed Team <hi@zed.dev>"]
--- a/crates/zed/RELEASE_CHANNEL
+++ b/crates/zed/RELEASE_CHANNEL
@@ -1 +1 @@
-dev
+stable
--- a/crates/zed/src/zed.rs
+++ b/crates/zed/src/zed.rs
@@ -823,8 +823,13 @@ pub fn handle_keymap_file_changes(
    })
    .detach();

-    cx.on_keyboard_layout_change(move |_| {
-        keyboard_layout_tx.unbounded_send(()).ok();
+    let mut current_mapping = settings::get_key_equivalents(cx.keyboard_layout());
+    cx.on_keyboard_layout_change(move |cx| {
+        let next_mapping = settings::get_key_equivalents(cx.keyboard_layout());
+        if next_mapping != current_mapping {
+            current_mapping = next_mapping;
+            keyboard_layout_tx.unbounded_send(()).ok();
+        }
    })
    .detach();

--- a/script/create-draft-release
+++ b/script/create-draft-release
@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+
+preview=""
+if [[ "$GITHUB_REF_NAME" == *"-pre" ]]; then
+    preview="-p"
+fi
+
+gh release create -t "$GITHUB_REF_NAME" -d "$GITHUB_REF_NAME" -F "$1" $preview
--- a/script/determine-release-channel
+++ b/script/determine-release-channel
@@ -15,7 +15,7 @@ version=$(script/get-crate-version zed)
 channel=$(cat crates/zed/RELEASE_CHANNEL)
 echo "Publishing version: ${version} on release channel ${channel}"
 echo "RELEASE_CHANNEL=${channel}" >> $GITHUB_ENV
-echo "RELEASE_VERSION="${version}" >> $GITHUB_ENV
+echo "RELEASE_VERSION=${version}" >> $GITHUB_ENV

 expected_tag_name=""
 case ${channel} in
--- a/script/draft-release-notes
+++ b/script/draft-release-notes
@@ -19,24 +19,45 @@ async function main() {
    process.exit(1);
  }

-  let priorVersion = [parts[0], parts[1], parts[2] - 1].join(".");
-  let suffix = "";
-
-  if (channel == "preview") {
-    suffix = "-pre";
-    if (parts[2] == 0) {
-      priorVersion = [parts[0], parts[1] - 1, 0].join(".");
-    }
-  } else if (!ensureTag(`v${priorVersion}`)) {
-    console.log("Copy the release notes from preview.");
+  // currently we can only draft notes for patch releases.
+  if (parts[2] == 0) {
    process.exit(0);
  }

+  let priorVersion = [parts[0], parts[1], parts[2] - 1].join(".");
+  let suffix = channel == "preview" ? "-pre" : "";
  let [tag, priorTag] = [`v${version}${suffix}`, `v${priorVersion}${suffix}`];

-  if (!ensureTag(tag) || !ensureTag(priorTag)) {
-    console.log("Could not draft release notes, missing a tag:", tag, priorTag);
-    process.exit(0);
+  try {
+    execFileSync("rm", ["-rf", "target/shallow_clone"]);
+    execFileSync("git", [
+      "clone",
+      "https://github.com/zed-industries/zed",
+      "target/shallow_clone",
+      "--filter=tree:0",
+      "--no-checkout",
+      "--branch",
+      tag,
+      "--depth",
+      100,
+    ]);
+    execFileSync("git", [
+      "-C",
+      "target/shallow_clone",
+      "rev-parse",
+      "--verify",
+      tag,
+    ]);
+    execFileSync("git", [
+      "-C",
+      "target/shallow_clone",
+      "rev-parse",
+      "--verify",
+      priorTag,
+    ]);
+  } catch (e) {
+    console.error(e.stderr.toString());
+    process.exit(1);
  }

  const newCommits = getCommits(priorTag, tag);
@@ -64,16 +85,18 @@ async function main() {
  }

  console.log(releaseNotes.join("\n") + "\n");
-  console.log("<!-- ");
-  console.log(missing.join("\n"));
-  console.log(skipped.join("\n"));
-  console.log("-->");
 }

 function getCommits(oldTag, newTag) {
  const pullRequestNumbers = execFileSync(
    "git",
-    ["log", `${oldTag}..${newTag}`, "--format=DIVIDER\n%H|||%B"],
+    [
+      "-C",
+      "target/shallow_clone",
+      "log",
+      `${oldTag}..${newTag}`,
+      "--format=DIVIDER\n%H|||%B",
+    ],
    { encoding: "utf8" },
  )
    .replace(/\r\n/g, "\n")
@@ -103,18 +126,3 @@ function getCommits(oldTag, newTag) {

  return pullRequestNumbers;
 }
-
-function ensureTag(tag) {
-  try {
-    execFileSync("git", ["rev-parse", "--verify", tag]);
-    return true;
-  } catch (e) {
-    try {
-      execFileSync("git"[("fetch", "origin", "--shallow-exclude", tag)]);
-      execFileSync("git"[("fetch", "origin", "--deepen", "1")]);
-      return true;
-    } catch (e) {
-      return false;
-    }
-  }
-}
Author	SHA1	Message	Date
Zed Bot	c3657f15d6	Bump to 0.162.4 for @ConradIrwin	2024-11-21 18:59:30 +00:00
Conrad Irwin	f6f1191a58	Use our own git clone in draft release notes (#20956 ) It turns out that messing with the git repo created by the github action is tricky, so we'll just clone our own. On my machine, a shallow tree-less clone takes <500ms Release Notes: - N/A	2024-11-21 11:55:46 -07:00
gcp-cherry-pick-bot[bot]	889e80f289	Fix keybindings on a Spanish ISO keyboard (cherry-pick #20995 ) (#20999 ) Cherry-picked Fix keybindings on a Spanish ISO keyboard (#20995) Co-Authored-By: Peter <peter@zed.dev> Also reformatted the mappings to be easier to read/edit by hand. Release Notes: - Fixed keyboard shortcuts on Spanish ISO keyboards --------- Co-authored-by: Peter <peter@zed.dev> Co-authored-by: Conrad Irwin <conrad.irwin@gmail.com> Co-authored-by: Peter <peter@zed.dev>	2024-11-21 10:26:45 -07:00
gcp-cherry-pick-bot[bot]	3e7c7e08cd	vim: Fix shortcuts that require shift+punct (cherry-pick #20990 ) (#20993 ) Cherry-picked vim: Fix shortcuts that require shift+punct (#20990) Fixes a bug I introduced in #20953 Release Notes: - N/A Co-authored-by: Conrad Irwin <conrad.irwin@gmail.com>	2024-11-21 09:54:08 -07:00
gcp-cherry-pick-bot[bot]	6e8cbfb4da	Drop platform lock when setting menu (cherry-pick #20962 ) (#20966 ) Cherry-picked Drop platform lock when setting menu (#20962) Turns out setting the menu (sometimes) calls `selected_range` on the input handler. https://zed-industries.slack.com/archives/C04S6T1T7TQ/p1732160078058279 Release Notes: - Fixed a panic when reloading keymaps Co-authored-by: Conrad Irwin <conrad.irwin@gmail.com>	2024-11-20 21:43:19 -07:00
gcp-cherry-pick-bot[bot]	30aa26f95f	Rename ime_key -> key_char and update behavior (cherry-pick #20953 ) (#20958 ) Cherry-picked Rename ime_key -> key_char and update behavior (#20953) As part of the recent changes to keyboard support, ime_key is no longer populated by the IME; but instead by the keyboard. As part of #20877 I changed some code to assume that falling back to key was ok, but this was not ok; instead we need to populate this more similarly to how it was done before #20336. The alternative fix could be to instead of simulating these events in our own code to push a fake native event back to the platform input handler. Closes #ISSUE Release Notes: - Fixed a bug where tapping `shift` coudl type "shift" if you had a binding on "shift shift" Co-authored-by: Conrad Irwin <conrad.irwin@gmail.com>	2024-11-20 20:54:15 -07:00
gcp-cherry-pick-bot[bot]	8758f5db73	Don't re-render the menu so often (cherry-pick #20914 ) (#20916 ) Cherry-picked Don't re-render the menu so often (#20914) Closes #20710 Release Notes: - Fixes opening the menu when Chinese Pinyin keyboard is in use Co-authored-by: Conrad Irwin <conrad.irwin@gmail.com>	2024-11-20 15:38:12 -07:00
Peter Tripp	f81608732f	Fix for fetch-tags error.	2024-11-20 12:02:58 -05:00
gcp-cherry-pick-bot[bot]	2536c1fc16	Remove comments from discord release announcements (cherry-pick #20888 ) (#20892 ) Cherry-picked Remove comments from discord release announcements (#20888) Release Notes: - N/A Co-authored-by: Conrad Irwin <conrad.irwin@gmail.com>	2024-11-20 09:05:03 -07:00
gcp-cherry-pick-bot[bot]	c4a382d7cb	vim: Fix jj to exit insert mode (cherry-pick #20890 ) (#20891 ) Cherry-picked vim: Fix jj to exit insert mode (#20890) Release Notes: - (Preview only) fixed binding `jj` to exit insert mode Co-authored-by: Conrad Irwin <conrad.irwin@gmail.com>	2024-11-20 09:04:52 -07:00
Joseph T. Lyons	3412f2cc8f	v0.162.x stable	2024-11-20 10:45:22 -05:00
Conrad Irwin	92066fd4c1	Use gh to edit release directly	2024-11-19 16:09:43 -07:00
Conrad Irwin	0f744b055a	Revert "DEBUG release-notes-script" This reverts commit `f6d3e53f25`.	2024-11-19 16:07:12 -07:00
Conrad Irwin	5d13bd0589	Revert "More debugging" This reverts commit `dab258a5be`.	2024-11-19 16:07:12 -07:00
gcp-cherry-pick-bot[bot]	9976553891	Fix space repeating in terminal (cherry-pick #20877 ) (#20879 ) Cherry-picked Fix space repeating in terminal (#20877) This is broken because of the way we try to emulate macOS's ApplePressAndHoldEnabled. Release Notes: - Fixed holding down space in the terminal (preview only) Co-authored-by: Conrad Irwin <conrad.irwin@gmail.com>	2024-11-19 15:58:57 -07:00
Conrad Irwin	dab258a5be	More debugging	2024-11-19 10:00:46 -07:00
Marshall Bowers	a1a304bb26	assistant: Fix evaluating slash commands in slash command output (like `/default`) (#20864 ) This PR fixes an issue where slash commands in the output of other slash commands were not being evaluated when configured to do so. Closes https://github.com/zed-industries/zed/issues/20820. Release Notes: - Fixed slash commands from other slash commands (like `/default`) not being evaluated (Preview only).	2024-11-19 11:21:47 -05:00
Conrad Irwin	f6d3e53f25	DEBUG release-notes-script	2024-11-19 08:37:49 -07:00
Zed Bot	38abf62878	Bump to 0.162.3 for @ConradIrwin	2024-11-19 03:20:00 +00:00
gcp-cherry-pick-bot[bot]	7d344004d0	Don't call setAllowsAutomaticKeyEquivalentLocalization on Big Sur (cherry-pick #20844 ) (#20846 ) Cherry-picked Don't call setAllowsAutomaticKeyEquivalentLocalization on Big Sur (#20844) Closes #20821 Release Notes: - Fixed a crash on Big Sur (preview only) Co-authored-by: Conrad Irwin <conrad.irwin@gmail.com>	2024-11-18 20:18:17 -07:00
Danilo Leal	416243b5ca	assistant: Adjust title summarization prompt (#20822 ) Meant to avoid the excessive use of "Here's a concise 3-7 word title..." and "Title:" instances we've been seeing lately. Follow up to: https://github.com/zed-industries/zed/pull/19530 Release Notes: - Improve prompt for generating title summaries, avoiding preambles	2024-11-18 17:16:48 -05:00
Kirill Bulatov	cc5adf2f0b	Disable signature help shown by default (#20726 ) Closes https://github.com/zed-industries/zed/issues/20725 Stop showing the pop-up that gets an issue open every now and then. Release Notes: - Stopped showing signature help after completions by default	2024-11-15 17:20:02 +02:00
Kirill Bulatov	c3112c5db7	Fix Linux rust-analyzer downloads in Preview (#20718 ) Follow-up of https://github.com/zed-industries/zed/pull/20408 Release Notes: - (Preview) Fixed broken rust-analyzer downloads	2024-11-15 11:59:23 +02:00
Peter Tripp	8fa471fccd	zed 0.162.2	2024-11-14 14:18:40 -05:00
David Soria Parra	182559ac31	context_servers: Upgrade protocol to version 2024-11-05 (#20615 ) This updates context servers to the most recent version Release Notes: - N/A Co-authored-by: Marshall Bowers <elliott.codes@gmail.com>	2024-11-14 13:05:16 -05:00
Marshall Bowers	88f20bb467	zed_extension_api: Release v0.2.0 (#20683 ) This PR releases v0.2.0 of the Zed extension API. Support for this version of the extension API will land in Zed v0.162.x. Release Notes: - N/A	2024-11-14 12:50:03 -05:00
Marshall Bowers	f5f9ae1116	Move `ExtensionStore` tests back to `extension_host` (#20682 ) This PR moves the tests for the `ExtensionStore` back into the `extension_host` crate. We now have a separate `TestExtensionRegistrationHooks` to use in the test that implements the minimal required functionality needed for the tests. This means that we can depend on the `theme` crate only in the tests. Release Notes: - N/A	2024-11-14 12:49:56 -05:00
Kirill Bulatov	5832328975	Use vim-like keybindings for splitting out of the file finder (#20680 ) Follow-up of https://github.com/zed-industries/zed/pull/20507 Release Notes: - (breaking Preview) Adjusted file finder split keybindings to be less conflicting Co-authored-by: Conrad Irwin <conrad@zed.dev>	2024-11-14 18:34:00 +02:00
Kyle Kelley	d51221e302	Allow base64 encoded images to be decoded with or without padding (#20616 ) The R kernel doesn't use base64 padding whereas the Python kernel (via matplotlib) sometimes uses padding. We have to use the `base64` crate's `Indifferent` mode. /cherry-pick v0.161.x Release Notes: - N/A	2024-11-13 16:03:47 -08:00
Max Brunsfeld	ba1fc41d14	Fix completions for non-built-in slash commands (#20632 ) Release Notes: - N/A Co-authored-by: Marshall <marshall@zed.dev>	2024-11-13 15:12:13 -08:00
Max Brunsfeld	4f47278ea6	Improve context server lifecycle management (#20622 ) This optimizes and fixes bugs in our logic for maintaining a set of running context servers, based on the combination of the user's `context_servers` settings and their installed extensions. Release Notes: - N/A --------- Co-authored-by: Marshall <marshall@zed.dev> Co-authored-by: Marshall Bowers <elliott.codes@gmail.com>	2024-11-13 15:05:52 -08:00
Marshall Bowers	e9f4facd39	Extract `ExtensionSlashCommand` to `assistant_slash_command` crate (#20617 ) This PR extracts the `ExtensionSlashCommand` implementation to the `assistant_slash_command` crate. The slash command related methods have been added to the `Extension` trait. We also create separate data types for the slash command data within the `extension` crate so that we can talk about them without depending on the `extension_host` or `assistant_slash_command`. Release Notes: - N/A	2024-11-13 15:05:44 -08:00
Marshall Bowers	baf0da2701	Decouple extension `Worktree` resource from `LspAdapterDelegate` (#20611 ) This PR decouples the extension `Worktree` resource from the `LspAdapterDelegate`. We now have a `WorktreeDelegate` trait that corresponds to the methods on the resource. We then create a `WorktreeDelegateAdapter` that can wrap an `LspAdapterDelegate` and implement the `WorktreeDelegate` trait. Release Notes: - N/A	2024-11-13 15:05:35 -08:00
Peter Tripp	0c6f5e2912	zed 0.162.1	2024-11-13 17:22:47 -05:00
Conrad Irwin	ff3d693abb	Don't double-localize menu shortcuts (#20623 ) Release Notes: - Don't have macOS localize our menu shortcuts that we already localized.	2024-11-13 13:57:08 -07:00
Conrad Irwin	f468a2b726	Don't send key equivalents to the input hanlder (#20621 ) Release Notes: - Fix `cmd-backtick` to change windows	2024-11-13 13:50:26 -07:00
Conrad Irwin	451409e328	Deadkeys 2 (#20612 ) Re-land of #20515 with less brokenness In particular it turns out that for control, the .characters() method returns the control code. This mostly didn't make a difference, except when the control code matched tab/enter/escape (for ctrl-y,ctrl-[/ctrl-c) as we interpreted the key incorrectly. Secondly, we were setting IME key too aggressively. This led to (in vim mode) cmd-shift-{ being interpreted as [, so vim would wait for a second [ before letting you change tab. Release Notes: - N/A	2024-11-13 12:53:13 -05:00
Peter Tripp	888385dbe4	Fix bad quote in script/determine-release-channel (#20613 )	2024-11-13 12:43:36 -05:00
Joseph T. Lyons	1ceb653442	v0.162.x preview	2024-11-13 11:47:39 -05:00