zed 0.196.4

Revert "gpui: Improve path rendering & global multisample anti-aliasing" (#34722 )
Reverts zed-industries/zed#29718 We've noticed some issues with Zed on Intel-based Macs where typing has become sluggish, and git bisect has seemed to point towards this PR. Reverting for now, until we can understand why it is causing this issue.
2025-07-18 12:40:43 -04:00 · 2025-07-18 12:36:45 -04:00 · 2025-07-18 12:45:44 +03:00 · 2025-07-17 20:03:03 -04:00 · 2025-07-17 19:25:14 -04:00 · 2025-07-17 19:23:38 -04:00
108 changed files with 4808 additions and 1954 deletions
--- a/.config/hakari.toml
+++ b/.config/hakari.toml
@@ -23,6 +23,8 @@ workspace-members = [
 ]
 third-party = [
    { name = "reqwest", version = "0.11.27" },
+    # build of remote_server should not include scap / its x11 dependency
+    { name = "scap", git = "https://github.com/zed-industries/scap", rev = "270538dc780f5240723233ff901e1054641ed318" },
 ]

 [final-excludes]
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -679,8 +679,10 @@ jobs:
    timeout-minutes: 60
    runs-on: github-8vcpu-ubuntu-2404
    if: |
+      false && (
      startsWith(github.ref, 'refs/tags/v')
      || contains(github.event.pull_request.labels.*.name, 'run-bundling')
+      )
    needs: [linux_tests]
    name: Build Zed on FreeBSD
    steps:
@@ -798,7 +800,7 @@ jobs:
    if: |
      startsWith(github.ref, 'refs/tags/v')
      && endsWith(github.ref, '-pre') && !endsWith(github.ref, '.0-pre')
-    needs: [bundle-mac, bundle-linux-x86_x64, bundle-linux-aarch64, bundle-windows-x64, freebsd]
+    needs: [bundle-mac, bundle-linux-x86_x64, bundle-linux-aarch64, bundle-windows-x64]
    runs-on:
      - self-hosted
      - bundle
--- a/.github/workflows/release_nightly.yml
+++ b/.github/workflows/release_nightly.yml
@@ -187,7 +187,7 @@ jobs:

  freebsd:
    timeout-minutes: 60
-    if: github.repository_owner == 'zed-industries'
+    if: false && github.repository_owner == 'zed-industries'
    runs-on: github-8vcpu-ubuntu-2404
    needs: tests
    name: Build Zed on FreeBSD
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -745,6 +745,7 @@ dependencies = [
 "futures 0.3.31",
 "gpui",
 "icons",
+ "indoc",
 "language",
 "language_model",
 "log",
@@ -778,6 +779,7 @@ dependencies = [
 "collections",
 "component",
 "derive_more 0.99.19",
+ "diffy",
 "editor",
 "feature_flags",
 "fs",
@@ -2146,7 +2148,7 @@ dependencies = [
 [[package]]
 name = "blade-graphics"
 version = "0.6.0"
-source = "git+https://github.com/kvark/blade?rev=416375211bb0b5826b3584dccdb6a43369e499ad#416375211bb0b5826b3584dccdb6a43369e499ad"
+source = "git+https://github.com/kvark/blade?rev=e0ec4e720957edd51b945b64dd85605ea54bcfe5#e0ec4e720957edd51b945b64dd85605ea54bcfe5"
 dependencies = [
 "ash",
 "ash-window",
@@ -2179,7 +2181,7 @@ dependencies = [
 [[package]]
 name = "blade-macros"
 version = "0.3.0"
-source = "git+https://github.com/kvark/blade?rev=416375211bb0b5826b3584dccdb6a43369e499ad#416375211bb0b5826b3584dccdb6a43369e499ad"
+source = "git+https://github.com/kvark/blade?rev=e0ec4e720957edd51b945b64dd85605ea54bcfe5#e0ec4e720957edd51b945b64dd85605ea54bcfe5"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -2189,7 +2191,7 @@ dependencies = [
 [[package]]
 name = "blade-util"
 version = "0.2.0"
-source = "git+https://github.com/kvark/blade?rev=416375211bb0b5826b3584dccdb6a43369e499ad#416375211bb0b5826b3584dccdb6a43369e499ad"
+source = "git+https://github.com/kvark/blade?rev=e0ec4e720957edd51b945b64dd85605ea54bcfe5#e0ec4e720957edd51b945b64dd85605ea54bcfe5"
 dependencies = [
 "blade-graphics",
 "bytemuck",
@@ -9094,6 +9096,7 @@ dependencies = [
 "util",
 "vercel",
 "workspace-hack",
+ "x_ai",
 "zed_llm_client",
 ]

@@ -14717,6 +14720,7 @@ dependencies = [
 "serde",
 "serde_json",
 "settings",
+ "telemetry",
 "theme",
 "tree-sitter-json",
 "tree-sitter-rust",
@@ -16448,6 +16452,7 @@ dependencies = [
 "schemars",
 "serde",
 "settings",
+ "settings_ui",
 "smallvec",
 "story",
 "telemetry",
@@ -19687,7 +19692,6 @@ dependencies = [
 "rustix 1.0.7",
 "rustls 0.23.26",
 "rustls-webpki 0.103.1",
- "scap",
 "schemars",
 "scopeguard",
 "sea-orm",
@@ -19735,9 +19739,7 @@ dependencies = [
 "wasmtime-cranelift",
 "wasmtime-environ",
 "winapi",
- "windows 0.61.1",
 "windows-core 0.61.0",
- "windows-future",
 "windows-numerics",
 "windows-sys 0.48.0",
 "windows-sys 0.52.0",
@@ -19843,6 +19845,17 @@ version = "0.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ec107c4503ea0b4a98ef47356329af139c0a4f7750e621cf2973cd3385ebcb3d"

+[[package]]
+name = "x_ai"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "schemars",
+ "serde",
+ "strum 0.27.1",
+ "workspace-hack",
+]
+
 [[package]]
 name = "xattr"
 version = "0.2.3"
@@ -20084,7 +20097,7 @@ dependencies = [

 [[package]]
 name = "zed"
-version = "0.196.0"
+version = "0.196.4"
 dependencies = [
 "activity_indicator",
 "agent",
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -179,6 +179,7 @@ members = [
    "crates/welcome",
    "crates/workspace",
    "crates/worktree",
+    "crates/x_ai",
    "crates/zed",
    "crates/zed_actions",
    "crates/zeta",
@@ -394,6 +395,7 @@ web_search_providers = { path = "crates/web_search_providers" }
 welcome = { path = "crates/welcome" }
 workspace = { path = "crates/workspace" }
 worktree = { path = "crates/worktree" }
+x_ai = { path = "crates/x_ai" }
 zed = { path = "crates/zed" }
 zed_actions = { path = "crates/zed_actions" }
 zeta = { path = "crates/zeta" }
@@ -432,9 +434,9 @@ aws-smithy-runtime-api = { version = "1.7.4", features = ["http-1x", "client"] }
 aws-smithy-types = { version = "1.3.0", features = ["http-body-1-x"] }
 base64 = "0.22"
 bitflags = "2.6.0"
-blade-graphics = { git = "https://github.com/kvark/blade", rev = "416375211bb0b5826b3584dccdb6a43369e499ad" }
-blade-macros = { git = "https://github.com/kvark/blade", rev = "416375211bb0b5826b3584dccdb6a43369e499ad" }
-blade-util = { git = "https://github.com/kvark/blade", rev = "416375211bb0b5826b3584dccdb6a43369e499ad" }
+blade-graphics = { git = "https://github.com/kvark/blade", rev = "e0ec4e720957edd51b945b64dd85605ea54bcfe5" }
+blade-macros = { git = "https://github.com/kvark/blade", rev = "e0ec4e720957edd51b945b64dd85605ea54bcfe5" }
+blade-util = { git = "https://github.com/kvark/blade", rev = "e0ec4e720957edd51b945b64dd85605ea54bcfe5" }
 blake3 = "1.5.3"
 bytes = "1.0"
 cargo_metadata = "0.19"
@@ -487,7 +489,7 @@ json_dotpath = "1.1"
 jsonschema = "0.30.0"
 jsonwebtoken = "9.3"
 jupyter-protocol = { git = "https://github.com/ConradIrwin/runtimed", rev = "7130c804216b6914355d15d0b91ea91f6babd734" }
-jupyter-websocket-client = { git = "https://github.com/ConradIrwin/runtimed", rev = "7130c804216b6914355d15d0b91ea91f6babd734" }
+jupyter-websocket-client = {  git = "https://github.com/ConradIrwin/runtimed" ,rev = "7130c804216b6914355d15d0b91ea91f6babd734" }
 libc = "0.2"
 libsqlite3-sys = { version = "0.30.1", features = ["bundled"] }
 linkify = "0.10.0"
@@ -498,7 +500,7 @@ metal = "0.29"
 moka = { version = "0.12.10", features = ["sync"] }
 naga = { version = "25.0", features = ["wgsl-in"] }
 nanoid = "0.4"
-nbformat = { git = "https://github.com/ConradIrwin/runtimed", rev = "7130c804216b6914355d15d0b91ea91f6babd734" }
+nbformat = {  git = "https://github.com/ConradIrwin/runtimed", rev = "7130c804216b6914355d15d0b91ea91f6babd734" }
 nix = "0.29"
 num-format = "0.4.4"
 objc = "0.2"
@@ -539,7 +541,7 @@ reqwest = { git = "https://github.com/zed-industries/reqwest.git", rev = "951c77
    "stream",
 ] }
 rsa = "0.9.6"
-runtimelib = { git = "https://github.com/ConradIrwin/runtimed", rev = "7130c804216b6914355d15d0b91ea91f6babd734", default-features = false, features = [
+runtimelib = {  git = "https://github.com/ConradIrwin/runtimed", rev = "7130c804216b6914355d15d0b91ea91f6babd734", default-features = false, features = [
    "async-dispatcher-runtime",
 ] }
 rust-embed = { version = "8.4", features = ["include-exclude"] }
@@ -547,6 +549,7 @@ rustc-demangle = "0.1.23"
 rustc-hash = "2.1.0"
 rustls = { version = "0.23.26" }
 rustls-platform-verifier = "0.5.0"
+# When updating scap rev, also update it in .config/hakari.toml
 scap = { git = "https://github.com/zed-industries/scap", rev = "270538dc780f5240723233ff901e1054641ed318", default-features = false }
 schemars = { version = "1.0", features = ["indexmap2"] }
 semver = "1.0"
--- a/assets/icons/ai_x_ai.svg
+++ b/assets/icons/ai_x_ai.svg
@@ -0,0 +1,3 @@
+<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <path d="m12.414 5.47.27 9.641h2.157l.27-13.15zM15.11.889h-3.293L6.651 7.613l1.647 2.142zM.889 15.11H4.18l1.647-2.142-1.647-2.143zm0-9.641 7.409 9.641h3.292L4.181 5.47z" fill="#000"/>
+</svg>
--- a/assets/icons/equal.svg
+++ b/assets/icons/equal.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-equal-icon lucide-equal"><line x1="5" x2="19" y1="9" y2="9"/><line x1="5" x2="19" y1="15" y2="15"/></svg>
--- a/assets/keymaps/default-linux.json
+++ b/assets/keymaps/default-linux.json
@@ -586,7 +586,7 @@
      "ctrl-shift-f": "pane::DeploySearch",
      "ctrl-shift-h": ["pane::DeploySearch", { "replace_enabled": true }],
      "ctrl-shift-t": "pane::ReopenClosedItem",
-      "ctrl-k ctrl-s": "zed::OpenKeymap",
+      "ctrl-k ctrl-s": "zed::OpenKeymapEditor",
      "ctrl-k ctrl-t": "theme_selector::Toggle",
      "ctrl-t": "project_symbols::Toggle",
      "ctrl-p": "file_finder::Toggle",
@@ -1118,7 +1118,9 @@
      "ctrl-f": "search::FocusSearch",
      "alt-find": "keymap_editor::ToggleKeystrokeSearch",
      "alt-ctrl-f": "keymap_editor::ToggleKeystrokeSearch",
-      "alt-c": "keymap_editor::ToggleConflictFilter"
+      "alt-c": "keymap_editor::ToggleConflictFilter",
+      "enter": "keymap_editor::EditBinding",
+      "alt-enter": "keymap_editor::CreateBinding"
    }
  },
  {
@@ -1129,5 +1131,21 @@
      "escape escape escape": "keystroke_input::StopRecording",
      "delete": "keystroke_input::ClearKeystrokes"
    }
+  },
+  {
+    "context": "KeybindEditorModal",
+    "use_key_equivalents": true,
+    "bindings": {
+      "ctrl-enter": "menu::Confirm",
+      "escape": "menu::Cancel"
+    }
+  },
+  {
+    "context": "KeybindEditorModal > Editor",
+    "use_key_equivalents": true,
+    "bindings": {
+      "up": "menu::SelectPrevious",
+      "down": "menu::SelectNext"
+    }
  }
 ]
--- a/assets/keymaps/default-macos.json
+++ b/assets/keymaps/default-macos.json
@@ -652,7 +652,7 @@
      "cmd-shift-f": "pane::DeploySearch",
      "cmd-shift-h": ["pane::DeploySearch", { "replace_enabled": true }],
      "cmd-shift-t": "pane::ReopenClosedItem",
-      "cmd-k cmd-s": "zed::OpenKeymap",
+      "cmd-k cmd-s": "zed::OpenKeymapEditor",
      "cmd-k cmd-t": "theme_selector::Toggle",
      "cmd-t": "project_symbols::Toggle",
      "cmd-p": "file_finder::Toggle",
@@ -1105,7 +1105,9 @@
      "ctrl-enter": "assistant::InlineAssist",
      "ctrl-_": null, // emacs undo
      // Some nice conveniences
-      "cmd-backspace": ["terminal::SendText", "\u0015"],
+      "cmd-backspace": ["terminal::SendText", "\u0015"], // ctrl-u: clear line
+      "alt-delete": ["terminal::SendText", "\u001bd"], // alt-d: delete word forward
+      "cmd-delete": ["terminal::SendText", "\u000b"], // ctrl-k: delete to end of line
      "cmd-right": ["terminal::SendText", "\u0005"],
      "cmd-left": ["terminal::SendText", "\u0001"],
      // Terminal.app compatibility
@@ -1215,7 +1217,9 @@
    "use_key_equivalents": true,
    "bindings": {
      "cmd-alt-f": "keymap_editor::ToggleKeystrokeSearch",
-      "cmd-alt-c": "keymap_editor::ToggleConflictFilter"
+      "cmd-alt-c": "keymap_editor::ToggleConflictFilter",
+      "enter": "keymap_editor::EditBinding",
+      "alt-enter": "keymap_editor::CreateBinding"
    }
  },
  {
@@ -1226,5 +1230,21 @@
      "escape escape escape": "keystroke_input::StopRecording",
      "delete": "keystroke_input::ClearKeystrokes"
    }
+  },
+  {
+    "context": "KeybindEditorModal",
+    "use_key_equivalents": true,
+    "bindings": {
+      "cmd-enter": "menu::Confirm",
+      "escape": "menu::Cancel"
+    }
+  },
+  {
+    "context": "KeybindEditorModal > Editor",
+    "use_key_equivalents": true,
+    "bindings": {
+      "up": "menu::SelectPrevious",
+      "down": "menu::SelectNext"
+    }
  }
 ]
--- a/assets/settings/default.json
+++ b/assets/settings/default.json
@@ -84,7 +84,7 @@
  "bottom_dock_layout": "contained",
  // The direction that you want to split panes horizontally. Defaults to "up"
  "pane_split_direction_horizontal": "up",
-  // The direction that you want to split panes horizontally. Defaults to "left"
+  // The direction that you want to split panes vertically. Defaults to "left"
  "pane_split_direction_vertical": "left",
  // Centered layout related settings.
  "centered_layout": {
@@ -817,7 +817,7 @@
          "edit_file": true,
          "fetch": true,
          "list_directory": true,
-          "project_notifications": true,
+          "project_notifications": false,
          "move_path": true,
          "now": true,
          "find_path": true,
@@ -837,7 +837,7 @@
          "diagnostics": true,
          "fetch": true,
          "list_directory": true,
-          "project_notifications": true,
+          "project_notifications": false,
          "now": true,
          "find_path": true,
          "read_file": true,
@@ -1671,6 +1671,10 @@
        "allowed": true
      }
    },
+    "SystemVerilog": {
+      "format_on_save": "off",
+      "use_on_type_format": false
+    },
    "Vue.js": {
      "language_servers": ["vue-language-server", "..."],
      "prettier": {
--- a/crates/acp/src/acp.rs
+++ b/crates/acp/src/acp.rs
@@ -1,10 +1,10 @@
 pub use acp::ToolCallId;
 use agent_servers::AgentServer;
-use agentic_coding_protocol::{self as acp, UserMessageChunk};
+use agentic_coding_protocol::{self as acp, ToolCallLocation, UserMessageChunk};
 use anyhow::{Context as _, Result, anyhow};
 use assistant_tool::ActionLog;
 use buffer_diff::BufferDiff;
-use editor::{MultiBuffer, PathKey};
+use editor::{Bias, MultiBuffer, PathKey};
 use futures::{FutureExt, channel::oneshot, future::BoxFuture};
 use gpui::{AppContext, AsyncApp, Context, Entity, EventEmitter, SharedString, Task, WeakEntity};
 use itertools::Itertools;
@@ -769,6 +769,11 @@ impl AcpThread {
            status,
        };

+        let location = call.locations.last().cloned();
+        if let Some(location) = location {
+            self.set_project_location(location, cx)
+        }
+
        self.push_entry(AgentThreadEntry::ToolCall(call), cx);

        id
@@ -831,6 +836,11 @@ impl AcpThread {
            }
        }

+        let location = call.locations.last().cloned();
+        if let Some(location) = location {
+            self.set_project_location(location, cx)
+        }
+
        cx.emit(AcpThreadEvent::EntryUpdated(ix));
        Ok(())
    }
@@ -852,6 +862,37 @@ impl AcpThread {
        }
    }

+    pub fn set_project_location(&self, location: ToolCallLocation, cx: &mut Context<Self>) {
+        self.project.update(cx, |project, cx| {
+            let Some(path) = project.project_path_for_absolute_path(&location.path, cx) else {
+                return;
+            };
+            let buffer = project.open_buffer(path, cx);
+            cx.spawn(async move |project, cx| {
+                let buffer = buffer.await?;
+
+                project.update(cx, |project, cx| {
+                    let position = if let Some(line) = location.line {
+                        let snapshot = buffer.read(cx).snapshot();
+                        let point = snapshot.clip_point(Point::new(line, 0), Bias::Left);
+                        snapshot.anchor_before(point)
+                    } else {
+                        Anchor::MIN
+                    };
+
+                    project.set_agent_location(
+                        Some(AgentLocation {
+                            buffer: buffer.downgrade(),
+                            position,
+                        }),
+                        cx,
+                    );
+                })
+            })
+            .detach_and_log_err(cx);
+        });
+    }
+
    /// Returns true if the last turn is awaiting tool authorization
    pub fn waiting_for_tool_confirmation(&self) -> bool {
        for entry in self.entries.iter().rev() {
@@ -1780,7 +1821,7 @@ mod tests {

                Ok(AgentServerCommand {
                    path: "node".into(),
-                    args: vec![cli_path, "--acp".into()],
+                    args: vec![cli_path, "--experimental-acp".into()],
                    env: None,
                })
            }
--- a/crates/agent/src/thread.rs
+++ b/crates/agent/src/thread.rs
@@ -21,6 +21,7 @@ use gpui::{
    AnyWindowHandle, App, AppContext, AsyncApp, Context, Entity, EventEmitter, SharedString, Task,
    WeakEntity, Window,
 };
+use http_client::StatusCode;
 use language_model::{
    ConfiguredModel, LanguageModel, LanguageModelCompletionError, LanguageModelCompletionEvent,
    LanguageModelExt as _, LanguageModelId, LanguageModelRegistry, LanguageModelRequest,
@@ -51,7 +52,19 @@ use uuid::Uuid;
 use zed_llm_client::{CompletionIntent, CompletionRequestStatus, UsageLimit};

 const MAX_RETRY_ATTEMPTS: u8 = 3;
-const BASE_RETRY_DELAY_SECS: u64 = 5;
+const BASE_RETRY_DELAY: Duration = Duration::from_secs(5);
+
+#[derive(Debug, Clone)]
+enum RetryStrategy {
+    ExponentialBackoff {
+        initial_delay: Duration,
+        max_attempts: u8,
+    },
+    Fixed {
+        delay: Duration,
+        max_attempts: u8,
+    },
+}

 #[derive(
    Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Serialize, Deserialize, JsonSchema,
@@ -383,6 +396,7 @@ pub struct Thread {
    remaining_turns: u32,
    configured_model: Option<ConfiguredModel>,
    profile: AgentProfile,
+    last_error_context: Option<(Arc<dyn LanguageModel>, CompletionIntent)>,
 }

 #[derive(Clone, Debug)]
@@ -476,10 +490,11 @@ impl Thread {
            retry_state: None,
            message_feedback: HashMap::default(),
            last_auto_capture_at: None,
+            last_error_context: None,
            last_received_chunk_at: None,
            request_callback: None,
            remaining_turns: u32::MAX,
-            configured_model,
+            configured_model: configured_model.clone(),
            profile: AgentProfile::new(profile_id, tools),
        }
    }
@@ -600,6 +615,7 @@ impl Thread {
            feedback: None,
            message_feedback: HashMap::default(),
            last_auto_capture_at: None,
+            last_error_context: None,
            last_received_chunk_at: None,
            request_callback: None,
            remaining_turns: u32::MAX,
@@ -1251,9 +1267,58 @@ impl Thread {

        self.flush_notifications(model.clone(), intent, cx);

-        let request = self.to_completion_request(model.clone(), intent, cx);
+        let _checkpoint = self.finalize_pending_checkpoint(cx);
+        self.stream_completion(
+            self.to_completion_request(model.clone(), intent, cx),
+            model,
+            intent,
+            window,
+            cx,
+        );
+    }

-        self.stream_completion(request, model, intent, window, cx);
+    pub fn retry_last_completion(
+        &mut self,
+        window: Option<AnyWindowHandle>,
+        cx: &mut Context<Self>,
+    ) {
+        // Clear any existing error state
+        self.retry_state = None;
+
+        // Use the last error context if available, otherwise fall back to configured model
+        let (model, intent) = if let Some((model, intent)) = self.last_error_context.take() {
+            (model, intent)
+        } else if let Some(configured_model) = self.configured_model.as_ref() {
+            let model = configured_model.model.clone();
+            let intent = if self.has_pending_tool_uses() {
+                CompletionIntent::ToolResults
+            } else {
+                CompletionIntent::UserPrompt
+            };
+            (model, intent)
+        } else if let Some(configured_model) = self.get_or_init_configured_model(cx) {
+            let model = configured_model.model.clone();
+            let intent = if self.has_pending_tool_uses() {
+                CompletionIntent::ToolResults
+            } else {
+                CompletionIntent::UserPrompt
+            };
+            (model, intent)
+        } else {
+            return;
+        };
+
+        self.send_to_model(model, intent, window, cx);
+    }
+
+    pub fn enable_burn_mode_and_retry(
+        &mut self,
+        window: Option<AnyWindowHandle>,
+        cx: &mut Context<Self>,
+    ) {
+        self.completion_mode = CompletionMode::Burn;
+        cx.emit(ThreadEvent::ProfileChanged);
+        self.retry_last_completion(window, cx);
    }

    pub fn used_tools_since_last_user_message(&self) -> bool {
@@ -1519,7 +1584,9 @@ impl Thread {
    ) -> Option<PendingToolUse> {
        let action_log = self.action_log.read(cx);

-        action_log.unnotified_stale_buffers(cx).next()?;
+        if !action_log.has_unnotified_user_edits() {
+            return None;
+        }

        // Represent notification as a simulated `project_notifications` tool call
        let tool_name = Arc::from("project_notifications");
@@ -1933,18 +2000,6 @@ impl Thread {
                                project.set_agent_location(None, cx);
                            });

-                            fn emit_generic_error(error: &anyhow::Error, cx: &mut Context<Thread>) {
-                                let error_message = error
-                                    .chain()
-                                    .map(|err| err.to_string())
-                                    .collect::<Vec<_>>()
-                                    .join("\n");
-                                cx.emit(ThreadEvent::ShowError(ThreadError::Message {
-                                    header: "Error interacting with language model".into(),
-                                    message: SharedString::from(error_message.clone()),
-                                }));
-                            }
-
                            if error.is::<PaymentRequiredError>() {
                                cx.emit(ThreadEvent::ShowError(ThreadError::PaymentRequired));
                            } else if let Some(error) =
@@ -1956,9 +2011,10 @@ impl Thread {
                            } else if let Some(completion_error) =
                                error.downcast_ref::<LanguageModelCompletionError>()
                            {
-                                use LanguageModelCompletionError::*;
                                match &completion_error {
-                                    PromptTooLarge { tokens, .. } => {
+                                    LanguageModelCompletionError::PromptTooLarge {
+                                        tokens, ..
+                                    } => {
                                        let tokens = tokens.unwrap_or_else(|| {
                                            // We didn't get an exact token count from the API, so fall back on our estimate.
                                            thread
@@ -1979,63 +2035,22 @@ impl Thread {
                                        });
                                        cx.notify();
                                    }
-                                    RateLimitExceeded {
-                                        retry_after: Some(retry_after),
-                                        ..
-                                    }
-                                    | ServerOverloaded {
-                                        retry_after: Some(retry_after),
-                                        ..
-                                    } => {
-                                        thread.handle_rate_limit_error(
-                                            &completion_error,
-                                            *retry_after,
-                                            model.clone(),
-                                            intent,
-                                            window,
-                                            cx,
-                                        );
-                                        retry_scheduled = true;
-                                    }
-                                    RateLimitExceeded { .. } | ServerOverloaded { .. } => {
-                                        retry_scheduled = thread.handle_retryable_error(
-                                            &completion_error,
-                                            model.clone(),
-                                            intent,
-                                            window,
-                                            cx,
-                                        );
-                                        if !retry_scheduled {
-                                            emit_generic_error(error, cx);
+                                    _ => {
+                                        if let Some(retry_strategy) =
+                                            Thread::get_retry_strategy(completion_error)
+                                        {
+                                            retry_scheduled = thread
+                                                .handle_retryable_error_with_delay(
+                                                    &completion_error,
+                                                    Some(retry_strategy),
+                                                    model.clone(),
+                                                    intent,
+                                                    window,
+                                                    cx,
+                                                );
                                        }
                                    }
-                                    ApiInternalServerError { .. }
-                                    | ApiReadResponseError { .. }
-                                    | HttpSend { .. } => {
-                                        retry_scheduled = thread.handle_retryable_error(
-                                            &completion_error,
-                                            model.clone(),
-                                            intent,
-                                            window,
-                                            cx,
-                                        );
-                                        if !retry_scheduled {
-                                            emit_generic_error(error, cx);
-                                        }
-                                    }
-                                    NoApiKey { .. }
-                                    | HttpResponseError { .. }
-                                    | BadRequestFormat { .. }
-                                    | AuthenticationError { .. }
-                                    | PermissionError { .. }
-                                    | ApiEndpointNotFound { .. }
-                                    | SerializeRequest { .. }
-                                    | BuildRequestBody { .. }
-                                    | DeserializeResponse { .. }
-                                    | Other { .. } => emit_generic_error(error, cx),
                                }
-                            } else {
-                                emit_generic_error(error, cx);
                            }

                            if !retry_scheduled {
@@ -2162,73 +2177,132 @@ impl Thread {
        });
    }

-    fn handle_rate_limit_error(
-        &mut self,
-        error: &LanguageModelCompletionError,
-        retry_after: Duration,
-        model: Arc<dyn LanguageModel>,
-        intent: CompletionIntent,
-        window: Option<AnyWindowHandle>,
-        cx: &mut Context<Self>,
-    ) {
-        // For rate limit errors, we only retry once with the specified duration
-        let retry_message = format!("{error}. Retrying in {} seconds…", retry_after.as_secs());
-        log::warn!(
-            "Retrying completion request in {} seconds: {error:?}",
-            retry_after.as_secs(),
-        );
+    fn get_retry_strategy(error: &LanguageModelCompletionError) -> Option<RetryStrategy> {
+        use LanguageModelCompletionError::*;

-        // Add a UI-only message instead of a regular message
-        let id = self.next_message_id.post_inc();
-        self.messages.push(Message {
-            id,
-            role: Role::System,
-            segments: vec![MessageSegment::Text(retry_message)],
-            loaded_context: LoadedContext::default(),
-            creases: Vec::new(),
-            is_hidden: false,
-            ui_only: true,
-        });
-        cx.emit(ThreadEvent::MessageAdded(id));
-        // Schedule the retry
-        let thread_handle = cx.entity().downgrade();
-
-        cx.spawn(async move |_thread, cx| {
-            cx.background_executor().timer(retry_after).await;
-
-            thread_handle
-                .update(cx, |thread, cx| {
-                    // Retry the completion
-                    thread.send_to_model(model, intent, window, cx);
+        // General strategy here:
+        // - If retrying won't help (e.g. invalid API key or payload too large), return None so we don't retry at all.
+        // - If it's a time-based issue (e.g. server overloaded, rate limit exceeded), try multiple times with exponential backoff.
+        // - If it's an issue that *might* be fixed by retrying (e.g. internal server error), just retry once.
+        match error {
+            HttpResponseError {
+                status_code: StatusCode::TOO_MANY_REQUESTS,
+                ..
+            } => Some(RetryStrategy::ExponentialBackoff {
+                initial_delay: BASE_RETRY_DELAY,
+                max_attempts: MAX_RETRY_ATTEMPTS,
+            }),
+            ServerOverloaded { retry_after, .. } | RateLimitExceeded { retry_after, .. } => {
+                Some(RetryStrategy::Fixed {
+                    delay: retry_after.unwrap_or(BASE_RETRY_DELAY),
+                    max_attempts: MAX_RETRY_ATTEMPTS,
                })
-                .log_err();
-        })
-        .detach();
-    }
-
-    fn handle_retryable_error(
-        &mut self,
-        error: &LanguageModelCompletionError,
-        model: Arc<dyn LanguageModel>,
-        intent: CompletionIntent,
-        window: Option<AnyWindowHandle>,
-        cx: &mut Context<Self>,
-    ) -> bool {
-        self.handle_retryable_error_with_delay(error, None, model, intent, window, cx)
+            }
+            UpstreamProviderError {
+                status,
+                retry_after,
+                ..
+            } => match *status {
+                StatusCode::TOO_MANY_REQUESTS | StatusCode::SERVICE_UNAVAILABLE => {
+                    Some(RetryStrategy::Fixed {
+                        delay: retry_after.unwrap_or(BASE_RETRY_DELAY),
+                        max_attempts: MAX_RETRY_ATTEMPTS,
+                    })
+                }
+                StatusCode::INTERNAL_SERVER_ERROR => Some(RetryStrategy::Fixed {
+                    delay: retry_after.unwrap_or(BASE_RETRY_DELAY),
+                    // Internal Server Error could be anything, so only retry once.
+                    max_attempts: 1,
+                }),
+                status => {
+                    // There is no StatusCode variant for the unofficial HTTP 529 ("The service is overloaded"),
+                    // but we frequently get them in practice. See https://http.dev/529
+                    if status.as_u16() == 529 {
+                        Some(RetryStrategy::Fixed {
+                            delay: retry_after.unwrap_or(BASE_RETRY_DELAY),
+                            max_attempts: MAX_RETRY_ATTEMPTS,
+                        })
+                    } else {
+                        None
+                    }
+                }
+            },
+            ApiInternalServerError { .. } => Some(RetryStrategy::Fixed {
+                delay: BASE_RETRY_DELAY,
+                max_attempts: 1,
+            }),
+            ApiReadResponseError { .. }
+            | HttpSend { .. }
+            | DeserializeResponse { .. }
+            | BadRequestFormat { .. } => Some(RetryStrategy::Fixed {
+                delay: BASE_RETRY_DELAY,
+                max_attempts: 1,
+            }),
+            // Retrying these errors definitely shouldn't help.
+            HttpResponseError {
+                status_code:
+                    StatusCode::PAYLOAD_TOO_LARGE | StatusCode::FORBIDDEN | StatusCode::UNAUTHORIZED,
+                ..
+            }
+            | SerializeRequest { .. }
+            | BuildRequestBody { .. }
+            | PromptTooLarge { .. }
+            | AuthenticationError { .. }
+            | PermissionError { .. }
+            | ApiEndpointNotFound { .. }
+            | NoApiKey { .. } => None,
+            // Retry all other 4xx and 5xx errors once.
+            HttpResponseError { status_code, .. }
+                if status_code.is_client_error() || status_code.is_server_error() =>
+            {
+                Some(RetryStrategy::Fixed {
+                    delay: BASE_RETRY_DELAY,
+                    max_attempts: 1,
+                })
+            }
+            // Conservatively assume that any other errors are non-retryable
+            HttpResponseError { .. } | Other(..) => None,
+        }
    }

    fn handle_retryable_error_with_delay(
        &mut self,
        error: &LanguageModelCompletionError,
-        custom_delay: Option<Duration>,
+        strategy: Option<RetryStrategy>,
        model: Arc<dyn LanguageModel>,
        intent: CompletionIntent,
        window: Option<AnyWindowHandle>,
        cx: &mut Context<Self>,
    ) -> bool {
+        // Store context for the Retry button
+        self.last_error_context = Some((model.clone(), intent));
+
+        // Only auto-retry if Burn Mode is enabled
+        if self.completion_mode != CompletionMode::Burn {
+            // Show error with retry options
+            cx.emit(ThreadEvent::ShowError(ThreadError::RetryableError {
+                message: format!(
+                    "{}\n\nTo automatically retry when similar errors happen, enable Burn Mode.",
+                    error
+                )
+                .into(),
+                can_enable_burn_mode: true,
+            }));
+            return false;
+        }
+
+        let Some(strategy) = strategy.or_else(|| Self::get_retry_strategy(error)) else {
+            return false;
+        };
+
+        let max_attempts = match &strategy {
+            RetryStrategy::ExponentialBackoff { max_attempts, .. } => *max_attempts,
+            RetryStrategy::Fixed { max_attempts, .. } => *max_attempts,
+        };
+
        let retry_state = self.retry_state.get_or_insert(RetryState {
            attempt: 0,
-            max_attempts: MAX_RETRY_ATTEMPTS,
+            max_attempts,
            intent,
        });

@@ -2238,20 +2312,24 @@ impl Thread {
        let intent = retry_state.intent;

        if attempt <= max_attempts {
-            // Use custom delay if provided (e.g., from rate limit), otherwise exponential backoff
-            let delay = if let Some(custom_delay) = custom_delay {
-                custom_delay
-            } else {
-                let delay_secs = BASE_RETRY_DELAY_SECS * 2u64.pow((attempt - 1) as u32);
-                Duration::from_secs(delay_secs)
+            let delay = match &strategy {
+                RetryStrategy::ExponentialBackoff { initial_delay, .. } => {
+                    let delay_secs = initial_delay.as_secs() * 2u64.pow((attempt - 1) as u32);
+                    Duration::from_secs(delay_secs)
+                }
+                RetryStrategy::Fixed { delay, .. } => *delay,
            };

            // Add a transient message to inform the user
            let delay_secs = delay.as_secs();
-            let retry_message = format!(
-                "{error}. Retrying (attempt {attempt} of {max_attempts}) \
-                in {delay_secs} seconds..."
-            );
+            let retry_message = if max_attempts == 1 {
+                format!("{error}. Retrying in {delay_secs} seconds...")
+            } else {
+                format!(
+                    "{error}. Retrying (attempt {attempt} of {max_attempts}) \
+                    in {delay_secs} seconds..."
+                )
+            };
            log::warn!(
                "Retrying completion request (attempt {attempt} of {max_attempts}) \
                in {delay_secs} seconds: {error:?}",
@@ -2290,18 +2368,15 @@ impl Thread {
            // Max retries exceeded
            self.retry_state = None;

-            let notification_text = if max_attempts == 1 {
-                "Failed after retrying.".into()
-            } else {
-                format!("Failed after retrying {} times.", max_attempts).into()
-            };
-
            // Stop generating since we're giving up on retrying.
            self.pending_completions.clear();

-            cx.emit(ThreadEvent::RetriesFailed {
-                message: notification_text,
-            });
+            // Show error alongside a Retry button, but no
+            // Enable Burn Mode button (since it's already enabled)
+            cx.emit(ThreadEvent::ShowError(ThreadError::RetryableError {
+                message: format!("Failed after retrying: {}", error).into(),
+                can_enable_burn_mode: false,
+            }));

            false
        }
@@ -3213,6 +3288,11 @@ pub enum ThreadError {
        header: SharedString,
        message: SharedString,
    },
+    #[error("Retryable error: {message}")]
+    RetryableError {
+        message: SharedString,
+        can_enable_burn_mode: bool,
+    },
 }

 #[derive(Debug, Clone)]
@@ -3258,9 +3338,6 @@ pub enum ThreadEvent {
    CancelEditing,
    CompletionCanceled,
    ProfileChanged,
-    RetriesFailed {
-        message: SharedString,
-    },
 }

 impl EventEmitter<ThreadEvent> for Thread {}
@@ -3288,7 +3365,6 @@ mod tests {
    use futures::stream::BoxStream;
    use gpui::TestAppContext;
    use http_client;
-    use indoc::indoc;
    use language_model::fake_provider::{FakeLanguageModel, FakeLanguageModelProvider};
    use language_model::{
        LanguageModelCompletionError, LanguageModelName, LanguageModelProviderId,
@@ -3617,6 +3693,7 @@ fn main() {{
    }

    #[gpui::test]
+    #[ignore] // turn this test on when project_notifications tool is re-enabled
    async fn test_stale_buffer_notification(cx: &mut TestAppContext) {
        init_test_settings(cx);

@@ -3649,6 +3726,7 @@ fn main() {{
                cx,
            );
        });
+        cx.run_until_parked();

        // We shouldn't have a stale buffer notification yet
        let notifications = thread.read_with(cx, |thread, _| {
@@ -3678,11 +3756,13 @@ fn main() {{
                cx,
            )
        });
+        cx.run_until_parked();

        // Check for the stale buffer warning
        thread.update(cx, |thread, cx| {
            thread.flush_notifications(model.clone(), CompletionIntent::UserPrompt, cx)
        });
+        cx.run_until_parked();

        let notifications = thread.read_with(cx, |thread, _cx| {
            find_tool_uses(thread, "project_notifications")
@@ -3696,12 +3776,8 @@ fn main() {{
            panic!("`project_notifications` should return text");
        };

-        let expected_content = indoc! {"[The following is an auto-generated notification; do not reply]
-
-        These files have changed since the last read:
-        - code.rs
-        "};
-        assert_eq!(notification_content, expected_content);
+        assert!(notification_content.contains("These files have changed since the last read:"));
+        assert!(notification_content.contains("code.rs"));

        // Insert another user message and flush notifications again
        thread.update(cx, |thread, cx| {
@@ -3717,6 +3793,7 @@ fn main() {{
        thread.update(cx, |thread, cx| {
            thread.flush_notifications(model.clone(), CompletionIntent::UserPrompt, cx)
        });
+        cx.run_until_parked();

        // There should be no new notifications (we already flushed one)
        let notifications = thread.read_with(cx, |thread, _cx| {
@@ -4171,6 +4248,11 @@ fn main() {{
        let project = create_test_project(cx, json!({})).await;
        let (_, _, thread, _, _base_model) = setup_test_environment(cx, project.clone()).await;

+        // Enable Burn Mode to allow retries
+        thread.update(cx, |thread, _| {
+            thread.set_completion_mode(CompletionMode::Burn);
+        });
+
        // Create model that returns overloaded error
        let model = Arc::new(ErrorInjector::new(TestError::Overloaded));

@@ -4192,7 +4274,7 @@ fn main() {{
            assert_eq!(retry_state.attempt, 1, "Should be first retry attempt");
            assert_eq!(
                retry_state.max_attempts, MAX_RETRY_ATTEMPTS,
-                "Should have default max attempts"
+                "Should retry MAX_RETRY_ATTEMPTS times for overloaded errors"
            );
        });

@@ -4244,6 +4326,11 @@ fn main() {{
        let project = create_test_project(cx, json!({})).await;
        let (_, _, thread, _, _base_model) = setup_test_environment(cx, project.clone()).await;

+        // Enable Burn Mode to allow retries
+        thread.update(cx, |thread, _| {
+            thread.set_completion_mode(CompletionMode::Burn);
+        });
+
        // Create model that returns internal server error
        let model = Arc::new(ErrorInjector::new(TestError::InternalServerError));

@@ -4265,7 +4352,7 @@ fn main() {{
            let retry_state = thread.retry_state.as_ref().unwrap();
            assert_eq!(retry_state.attempt, 1, "Should be first retry attempt");
            assert_eq!(
-                retry_state.max_attempts, MAX_RETRY_ATTEMPTS,
+                retry_state.max_attempts, 1,
                "Should have correct max attempts"
            );
        });
@@ -4281,8 +4368,8 @@ fn main() {{
                            if let MessageSegment::Text(text) = seg {
                                text.contains("internal")
                                    && text.contains("Fake")
-                                    && text
-                                        .contains(&format!("attempt 1 of {}", MAX_RETRY_ATTEMPTS))
+                                    && text.contains("Retrying in")
+                                    && !text.contains("attempt")
                            } else {
                                false
                            }
@@ -4320,8 +4407,13 @@ fn main() {{
        let project = create_test_project(cx, json!({})).await;
        let (_, _, thread, _, _base_model) = setup_test_environment(cx, project.clone()).await;

-        // Create model that returns overloaded error
-        let model = Arc::new(ErrorInjector::new(TestError::Overloaded));
+        // Enable Burn Mode to allow retries
+        thread.update(cx, |thread, _| {
+            thread.set_completion_mode(CompletionMode::Burn);
+        });
+
+        // Create model that returns internal server error
+        let model = Arc::new(ErrorInjector::new(TestError::InternalServerError));

        // Insert a user message
        thread.update(cx, |thread, cx| {
@@ -4371,11 +4463,14 @@ fn main() {{
            assert!(thread.retry_state.is_some(), "Should have retry state");
            let retry_state = thread.retry_state.as_ref().unwrap();
            assert_eq!(retry_state.attempt, 1, "Should be first retry attempt");
+            assert_eq!(
+                retry_state.max_attempts, 1,
+                "Internal server errors should only retry once"
+            );
        });

        // Advance clock for first retry
-        cx.executor()
-            .advance_clock(Duration::from_secs(BASE_RETRY_DELAY_SECS));
+        cx.executor().advance_clock(BASE_RETRY_DELAY);
        cx.run_until_parked();

        // Should have scheduled second retry - count retry messages
@@ -4395,93 +4490,25 @@ fn main() {{
                })
                .count()
        });
-        assert_eq!(retry_count, 2, "Should have scheduled second retry");
-
-        // Check retry state updated
-        thread.read_with(cx, |thread, _| {
-            assert!(thread.retry_state.is_some(), "Should have retry state");
-            let retry_state = thread.retry_state.as_ref().unwrap();
-            assert_eq!(retry_state.attempt, 2, "Should be second retry attempt");
-            assert_eq!(
-                retry_state.max_attempts, MAX_RETRY_ATTEMPTS,
-                "Should have correct max attempts"
-            );
-        });
-
-        // Advance clock for second retry (exponential backoff)
-        cx.executor()
-            .advance_clock(Duration::from_secs(BASE_RETRY_DELAY_SECS * 2));
-        cx.run_until_parked();
-
-        // Should have scheduled third retry
-        // Count all retry messages now
-        let retry_count = thread.update(cx, |thread, _| {
-            thread
-                .messages
-                .iter()
-                .filter(|m| {
-                    m.ui_only
-                        && m.segments.iter().any(|s| {
-                            if let MessageSegment::Text(text) = s {
-                                text.contains("Retrying") && text.contains("seconds")
-                            } else {
-                                false
-                            }
-                        })
-                })
-                .count()
-        });
        assert_eq!(
-            retry_count, MAX_RETRY_ATTEMPTS as usize,
-            "Should have scheduled third retry"
+            retry_count, 1,
+            "Should have only one retry for internal server errors"
        );

-        // Check retry state updated
+        // For internal server errors, we only retry once and then give up
+        // Check that retry_state is cleared after the single retry
        thread.read_with(cx, |thread, _| {
-            assert!(thread.retry_state.is_some(), "Should have retry state");
-            let retry_state = thread.retry_state.as_ref().unwrap();
-            assert_eq!(
-                retry_state.attempt, MAX_RETRY_ATTEMPTS,
-                "Should be at max retry attempt"
-            );
-            assert_eq!(
-                retry_state.max_attempts, MAX_RETRY_ATTEMPTS,
-                "Should have correct max attempts"
+            assert!(
+                thread.retry_state.is_none(),
+                "Retry state should be cleared after single retry"
            );
        });

-        // Advance clock for third retry (exponential backoff)
-        cx.executor()
-            .advance_clock(Duration::from_secs(BASE_RETRY_DELAY_SECS * 4));
-        cx.run_until_parked();
-
-        // No more retries should be scheduled after clock was advanced.
-        let retry_count = thread.update(cx, |thread, _| {
-            thread
-                .messages
-                .iter()
-                .filter(|m| {
-                    m.ui_only
-                        && m.segments.iter().any(|s| {
-                            if let MessageSegment::Text(text) = s {
-                                text.contains("Retrying") && text.contains("seconds")
-                            } else {
-                                false
-                            }
-                        })
-                })
-                .count()
-        });
-        assert_eq!(
-            retry_count, MAX_RETRY_ATTEMPTS as usize,
-            "Should not exceed max retries"
-        );
-
-        // Final completion count should be initial + max retries
+        // Verify total attempts (1 initial + 1 retry)
        assert_eq!(
            *completion_count.lock(),
-            (MAX_RETRY_ATTEMPTS + 1) as usize,
-            "Should have made initial + max retry attempts"
+            2,
+            "Should have attempted once plus 1 retry"
        );
    }

@@ -4492,6 +4519,11 @@ fn main() {{
        let project = create_test_project(cx, json!({})).await;
        let (_, _, thread, _, _base_model) = setup_test_environment(cx, project.clone()).await;

+        // Enable Burn Mode to allow retries
+        thread.update(cx, |thread, _| {
+            thread.set_completion_mode(CompletionMode::Burn);
+        });
+
        // Create model that returns overloaded error
        let model = Arc::new(ErrorInjector::new(TestError::Overloaded));

@@ -4501,13 +4533,13 @@ fn main() {{
        });

        // Track events
-        let retries_failed = Arc::new(Mutex::new(false));
-        let retries_failed_clone = retries_failed.clone();
+        let stopped_with_error = Arc::new(Mutex::new(false));
+        let stopped_with_error_clone = stopped_with_error.clone();

        let _subscription = thread.update(cx, |_, cx| {
            cx.subscribe(&thread, move |_, _, event: &ThreadEvent, _| {
-                if let ThreadEvent::RetriesFailed { .. } = event {
-                    *retries_failed_clone.lock() = true;
+                if let ThreadEvent::Stopped(Err(_)) = event {
+                    *stopped_with_error_clone.lock() = true;
                }
            })
        });
@@ -4519,23 +4551,11 @@ fn main() {{
        cx.run_until_parked();

        // Advance through all retries
-        for i in 0..MAX_RETRY_ATTEMPTS {
-            let delay = if i == 0 {
-                BASE_RETRY_DELAY_SECS
-            } else {
-                BASE_RETRY_DELAY_SECS * 2u64.pow(i as u32 - 1)
-            };
-            cx.executor().advance_clock(Duration::from_secs(delay));
+        for _ in 0..MAX_RETRY_ATTEMPTS {
+            cx.executor().advance_clock(BASE_RETRY_DELAY);
            cx.run_until_parked();
        }

-        // After the 3rd retry is scheduled, we need to wait for it to execute and fail
-        // The 3rd retry has a delay of BASE_RETRY_DELAY_SECS * 4 (20 seconds)
-        let final_delay = BASE_RETRY_DELAY_SECS * 2u64.pow((MAX_RETRY_ATTEMPTS - 1) as u32);
-        cx.executor()
-            .advance_clock(Duration::from_secs(final_delay));
-        cx.run_until_parked();
-
        let retry_count = thread.update(cx, |thread, _| {
            thread
                .messages
@@ -4553,14 +4573,14 @@ fn main() {{
                .count()
        });

-        // After max retries, should emit RetriesFailed event
+        // After max retries, should emit Stopped(Err(...)) event
        assert_eq!(
            retry_count, MAX_RETRY_ATTEMPTS as usize,
-            "Should have attempted max retries"
+            "Should have attempted MAX_RETRY_ATTEMPTS retries for overloaded errors"
        );
        assert!(
-            *retries_failed.lock(),
-            "Should emit RetriesFailed event after max retries exceeded"
+            *stopped_with_error.lock(),
+            "Should emit Stopped(Err(...)) event after max retries exceeded"
        );

        // Retry state should be cleared
@@ -4578,7 +4598,7 @@ fn main() {{
                .count();
            assert_eq!(
                retry_messages, MAX_RETRY_ATTEMPTS as usize,
-                "Should have one retry message per attempt"
+                "Should have MAX_RETRY_ATTEMPTS retry messages for overloaded errors"
            );
        });
    }
@@ -4590,6 +4610,11 @@ fn main() {{
        let project = create_test_project(cx, json!({})).await;
        let (_, _, thread, _, _base_model) = setup_test_environment(cx, project.clone()).await;

+        // Enable Burn Mode to allow retries
+        thread.update(cx, |thread, _| {
+            thread.set_completion_mode(CompletionMode::Burn);
+        });
+
        // We'll use a wrapper to switch behavior after first failure
        struct RetryTestModel {
            inner: Arc<FakeLanguageModel>,
@@ -4716,8 +4741,7 @@ fn main() {{
        });

        // Wait for retry
-        cx.executor()
-            .advance_clock(Duration::from_secs(BASE_RETRY_DELAY_SECS));
+        cx.executor().advance_clock(BASE_RETRY_DELAY);
        cx.run_until_parked();

        // Stream some successful content
@@ -4759,6 +4783,11 @@ fn main() {{
        let project = create_test_project(cx, json!({})).await;
        let (_, _, thread, _, _base_model) = setup_test_environment(cx, project.clone()).await;

+        // Enable Burn Mode to allow retries
+        thread.update(cx, |thread, _| {
+            thread.set_completion_mode(CompletionMode::Burn);
+        });
+
        // Create a model that fails once then succeeds
        struct FailOnceModel {
            inner: Arc<FakeLanguageModel>,
@@ -4879,8 +4908,7 @@ fn main() {{
        });

        // Wait for retry delay
-        cx.executor()
-            .advance_clock(Duration::from_secs(BASE_RETRY_DELAY_SECS));
+        cx.executor().advance_clock(BASE_RETRY_DELAY);
        cx.run_until_parked();

        // The retry should now use our FailOnceModel which should succeed
@@ -4921,6 +4949,11 @@ fn main() {{
        let project = create_test_project(cx, json!({})).await;
        let (_, _, thread, _, _base_model) = setup_test_environment(cx, project.clone()).await;

+        // Enable Burn Mode to allow retries
+        thread.update(cx, |thread, _| {
+            thread.set_completion_mode(CompletionMode::Burn);
+        });
+
        // Create a model that returns rate limit error with retry_after
        struct RateLimitModel {
            inner: Arc<FakeLanguageModel>,
@@ -5039,9 +5072,15 @@ fn main() {{

        thread.read_with(cx, |thread, _| {
            assert!(
-                thread.retry_state.is_none(),
-                "Rate limit errors should not set retry_state"
+                thread.retry_state.is_some(),
+                "Rate limit errors should set retry_state"
            );
+            if let Some(retry_state) = &thread.retry_state {
+                assert_eq!(
+                    retry_state.max_attempts, MAX_RETRY_ATTEMPTS,
+                    "Rate limit errors should use MAX_RETRY_ATTEMPTS"
+                );
+            }
        });

        // Verify we have one retry message
@@ -5074,18 +5113,15 @@ fn main() {{
                .find(|msg| msg.role == Role::System && msg.ui_only)
                .expect("Should have a retry message");

-            // Check that the message doesn't contain attempt count
+            // Check that the message contains attempt count since we use retry_state
            if let Some(MessageSegment::Text(text)) = retry_message.segments.first() {
                assert!(
-                    !text.contains("attempt"),
-                    "Rate limit retry message should not contain attempt count"
+                    text.contains(&format!("attempt 1 of {}", MAX_RETRY_ATTEMPTS)),
+                    "Rate limit retry message should contain attempt count with MAX_RETRY_ATTEMPTS"
                );
                assert!(
-                    text.contains(&format!(
-                        "Retrying in {} seconds",
-                        TEST_RATE_LIMIT_RETRY_SECS
-                    )),
-                    "Rate limit retry message should contain retry delay"
+                    text.contains("Retrying"),
+                    "Rate limit retry message should contain retry text"
                );
            }
        });
@@ -5191,6 +5227,79 @@ fn main() {{
        );
    }

+    #[gpui::test]
+    async fn test_no_retry_without_burn_mode(cx: &mut TestAppContext) {
+        init_test_settings(cx);
+
+        let project = create_test_project(cx, json!({})).await;
+        let (_, _, thread, _, _base_model) = setup_test_environment(cx, project.clone()).await;
+
+        // Ensure we're in Normal mode (not Burn mode)
+        thread.update(cx, |thread, _| {
+            thread.set_completion_mode(CompletionMode::Normal);
+        });
+
+        // Track error events
+        let error_events = Arc::new(Mutex::new(Vec::new()));
+        let error_events_clone = error_events.clone();
+
+        let _subscription = thread.update(cx, |_, cx| {
+            cx.subscribe(&thread, move |_, _, event: &ThreadEvent, _| {
+                if let ThreadEvent::ShowError(error) = event {
+                    error_events_clone.lock().push(error.clone());
+                }
+            })
+        });
+
+        // Create model that returns overloaded error
+        let model = Arc::new(ErrorInjector::new(TestError::Overloaded));
+
+        // Insert a user message
+        thread.update(cx, |thread, cx| {
+            thread.insert_user_message("Hello!", ContextLoadResult::default(), None, vec![], cx);
+        });
+
+        // Start completion
+        thread.update(cx, |thread, cx| {
+            thread.send_to_model(model.clone(), CompletionIntent::UserPrompt, None, cx);
+        });
+
+        cx.run_until_parked();
+
+        // Verify no retry state was created
+        thread.read_with(cx, |thread, _| {
+            assert!(
+                thread.retry_state.is_none(),
+                "Should not have retry state in Normal mode"
+            );
+        });
+
+        // Check that a retryable error was reported
+        let errors = error_events.lock();
+        assert!(!errors.is_empty(), "Should have received an error event");
+
+        if let ThreadError::RetryableError {
+            message: _,
+            can_enable_burn_mode,
+        } = &errors[0]
+        {
+            assert!(
+                *can_enable_burn_mode,
+                "Error should indicate burn mode can be enabled"
+            );
+        } else {
+            panic!("Expected RetryableError, got {:?}", errors[0]);
+        }
+
+        // Verify the thread is no longer generating
+        thread.read_with(cx, |thread, _| {
+            assert!(
+                !thread.is_generating(),
+                "Should not be generating after error without retry"
+            );
+        });
+    }
+
    #[gpui::test]
    async fn test_retry_cancelled_on_stop(cx: &mut TestAppContext) {
        init_test_settings(cx);
@@ -5198,6 +5307,11 @@ fn main() {{
        let project = create_test_project(cx, json!({})).await;
        let (_, _, thread, _, _base_model) = setup_test_environment(cx, project.clone()).await;

+        // Enable Burn Mode to allow retries
+        thread.update(cx, |thread, _| {
+            thread.set_completion_mode(CompletionMode::Burn);
+        });
+
        // Create model that returns overloaded error
        let model = Arc::new(ErrorInjector::new(TestError::Overloaded));

--- a/crates/agent_servers/src/agent_servers.rs
+++ b/crates/agent_servers/src/agent_servers.rs
@@ -56,7 +56,7 @@ pub trait AgentServer: Send {
    ) -> impl Future<Output = Result<AgentServerVersion>> + Send;
 }

-const GEMINI_ACP_ARG: &str = "--acp";
+const GEMINI_ACP_ARG: &str = "--experimental-acp";

 impl AgentServer for Gemini {
    async fn command(
--- a/crates/agent_ui/src/active_thread.rs
+++ b/crates/agent_ui/src/active_thread.rs
@@ -996,30 +996,57 @@ impl ActiveThread {
            | ThreadEvent::SummaryChanged => {
                self.save_thread(cx);
            }
-            ThreadEvent::Stopped(reason) => match reason {
-                Ok(StopReason::EndTurn | StopReason::MaxTokens) => {
-                    let used_tools = self.thread.read(cx).used_tools_since_last_user_message();
-                    self.play_notification_sound(window, cx);
-                    self.show_notification(
-                        if used_tools {
-                            "Finished running tools"
-                        } else {
-                            "New message"
-                        },
-                        IconName::ZedAssistant,
-                        window,
-                        cx,
-                    );
+            ThreadEvent::Stopped(reason) => {
+                match reason {
+                    Ok(StopReason::EndTurn | StopReason::MaxTokens) => {
+                        let used_tools = self.thread.read(cx).used_tools_since_last_user_message();
+                        self.notify_with_sound(
+                            if used_tools {
+                                "Finished running tools"
+                            } else {
+                                "New message"
+                            },
+                            IconName::ZedAssistant,
+                            window,
+                            cx,
+                        );
+                    }
+                    Ok(StopReason::ToolUse) => {
+                        // Don't notify for intermediate tool use
+                    }
+                    Ok(StopReason::Refusal) => {
+                        self.notify_with_sound(
+                            "Language model refused to respond",
+                            IconName::Warning,
+                            window,
+                            cx,
+                        );
+                    }
+                    Err(error) => {
+                        self.notify_with_sound(
+                            "Agent stopped due to an error",
+                            IconName::Warning,
+                            window,
+                            cx,
+                        );
+
+                        let error_message = error
+                            .chain()
+                            .map(|err| err.to_string())
+                            .collect::<Vec<_>>()
+                            .join("\n");
+                        self.last_error = Some(ThreadError::Message {
+                            header: "Error".into(),
+                            message: error_message.into(),
+                        });
+                    }
                }
-                _ => {}
-            },
+            }
            ThreadEvent::ToolConfirmationNeeded => {
-                self.play_notification_sound(window, cx);
-                self.show_notification("Waiting for tool confirmation", IconName::Info, window, cx);
+                self.notify_with_sound("Waiting for tool confirmation", IconName::Info, window, cx);
            }
            ThreadEvent::ToolUseLimitReached => {
-                self.play_notification_sound(window, cx);
-                self.show_notification(
+                self.notify_with_sound(
                    "Consecutive tool use limit reached.",
                    IconName::Warning,
                    window,
@@ -1162,9 +1189,6 @@ impl ActiveThread {
                self.save_thread(cx);
                cx.notify();
            }
-            ThreadEvent::RetriesFailed { message } => {
-                self.show_notification(message, ui::IconName::Warning, window, cx);
-            }
        }
    }

@@ -1219,6 +1243,17 @@ impl ActiveThread {
        }
    }

+    fn notify_with_sound(
+        &mut self,
+        caption: impl Into<SharedString>,
+        icon: IconName,
+        window: &mut Window,
+        cx: &mut Context<ActiveThread>,
+    ) {
+        self.play_notification_sound(window, cx);
+        self.show_notification(caption, icon, window, cx);
+    }
+
    fn pop_up(
        &mut self,
        icon: IconName,
--- a/crates/agent_ui/src/agent_configuration.rs
+++ b/crates/agent_ui/src/agent_configuration.rs
@@ -24,9 +24,10 @@ use project::{
    context_server_store::{ContextServerConfiguration, ContextServerStatus, ContextServerStore},
    project_settings::{ContextServerSettings, ProjectSettings},
 };
+use proto::Plan;
 use settings::{Settings, update_settings_file};
 use ui::{
-    ContextMenu, Disclosure, Divider, DividerColor, ElevationIndex, Indicator, PopoverMenu,
+    Chip, ContextMenu, Disclosure, Divider, DividerColor, ElevationIndex, Indicator, PopoverMenu,
    Scrollbar, ScrollbarState, Switch, SwitchColor, Tooltip, prelude::*,
 };
 use util::ResultExt as _;
@@ -171,6 +172,15 @@ impl AgentConfiguration {
            .copied()
            .unwrap_or(false);

+        let is_zed_provider = provider.id() == ZED_CLOUD_PROVIDER_ID;
+        let current_plan = if is_zed_provider {
+            self.workspace
+                .upgrade()
+                .and_then(|workspace| workspace.read(cx).user_store().read(cx).current_plan())
+        } else {
+            None
+        };
+
        v_flex()
            .when(is_expanded, |this| this.mb_2())
            .child(
@@ -208,14 +218,31 @@ impl AgentConfiguration {
                                            .size(IconSize::Small)
                                            .color(Color::Muted),
                                    )
-                                    .child(Label::new(provider_name.clone()).size(LabelSize::Large))
-                                    .when(
-                                        provider.is_authenticated(cx) && !is_expanded,
-                                        |parent| {
-                                            parent.child(
-                                                Icon::new(IconName::Check).color(Color::Success),
+                                    .child(
+                                        h_flex()
+                                            .gap_1()
+                                            .child(
+                                                Label::new(provider_name.clone())
+                                                    .size(LabelSize::Large),
                                            )
-                                        },
+                                            .map(|this| {
+                                                if is_zed_provider {
+                                                    this.gap_2().child(
+                                                        self.render_zed_plan_info(current_plan, cx),
+                                                    )
+                                                } else {
+                                                    this.when(
+                                                        provider.is_authenticated(cx)
+                                                            && !is_expanded,
+                                                        |parent| {
+                                                            parent.child(
+                                                                Icon::new(IconName::Check)
+                                                                    .color(Color::Success),
+                                                            )
+                                                        },
+                                                    )
+                                                }
+                                            }),
                                    ),
                            )
                            .child(
@@ -431,6 +458,37 @@ impl AgentConfiguration {
            .child(self.render_sound_notification(cx))
    }

+    fn render_zed_plan_info(&self, plan: Option<Plan>, cx: &mut Context<Self>) -> impl IntoElement {
+        if let Some(plan) = plan {
+            let free_chip_bg = cx
+                .theme()
+                .colors()
+                .editor_background
+                .opacity(0.5)
+                .blend(cx.theme().colors().text_accent.opacity(0.05));
+
+            let pro_chip_bg = cx
+                .theme()
+                .colors()
+                .editor_background
+                .opacity(0.5)
+                .blend(cx.theme().colors().text_accent.opacity(0.2));
+
+            let (plan_name, label_color, bg_color) = match plan {
+                Plan::Free => ("Free", Color::Default, free_chip_bg),
+                Plan::ZedProTrial => ("Pro Trial", Color::Accent, pro_chip_bg),
+                Plan::ZedPro => ("Pro", Color::Accent, pro_chip_bg),
+            };
+
+            Chip::new(plan_name.to_string())
+                .bg_color(bg_color)
+                .label_color(label_color)
+                .into_any_element()
+        } else {
+            div().into_any_element()
+        }
+    }
+
    fn render_context_servers_section(
        &mut self,
        window: &mut Window,
@@ -491,6 +549,7 @@ impl AgentConfiguration {
                                        category_filter: Some(
                                            ExtensionCategoryFilter::ContextServers,
                                        ),
+                                        id: None,
                                    }
                                    .boxed_clone(),
                                    cx,
--- a/crates/agent_ui/src/agent_diff.rs
+++ b/crates/agent_ui/src/agent_diff.rs
@@ -1488,7 +1488,6 @@ impl AgentDiff {
            | ThreadEvent::ToolConfirmationNeeded
            | ThreadEvent::ToolUseLimitReached
            | ThreadEvent::CancelEditing
-            | ThreadEvent::RetriesFailed { .. }
            | ThreadEvent::ProfileChanged => {}
        }
    }
--- a/crates/agent_ui/src/agent_panel.rs
+++ b/crates/agent_ui/src/agent_panel.rs
@@ -64,8 +64,9 @@ use theme::ThemeSettings;
 use time::UtcOffset;
 use ui::utils::WithRemSize;
 use ui::{
-    Banner, Callout, CheckboxWithLabel, ContextMenu, ElevationIndex, KeyBinding, PopoverMenu,
-    PopoverMenuHandle, ProgressBar, Tab, Tooltip, Vector, VectorName, prelude::*,
+    Banner, Button, Callout, CheckboxWithLabel, ContextMenu, ElevationIndex, IconPosition,
+    KeyBinding, PopoverMenu, PopoverMenuHandle, ProgressBar, Tab, Tooltip, Vector, VectorName,
+    prelude::*,
 };
 use util::ResultExt as _;
 use workspace::{
@@ -1921,6 +1922,7 @@ impl AgentPanel {
                                category_filter: Some(
                                    zed_actions::ExtensionCategoryFilter::ContextServers,
                                ),
+                                id: None,
                            }),
                        )
                        .action("Add Custom Server…", Box::new(AddContextServer))
@@ -1974,48 +1976,45 @@ impl AgentPanel {
    }

    fn render_token_count(&self, cx: &App) -> Option<AnyElement> {
-        let (active_thread, message_editor) = match &self.active_view {
+        match &self.active_view {
            ActiveView::Thread {
                thread,
                message_editor,
                ..
-            } => (thread.read(cx), message_editor.read(cx)),
-            ActiveView::AcpThread { .. } => {
-                return None;
-            }
-            ActiveView::TextThread { .. } | ActiveView::History | ActiveView::Configuration => {
-                return None;
-            }
-        };
+            } => {
+                let active_thread = thread.read(cx);
+                let message_editor = message_editor.read(cx);

-        let editor_empty = message_editor.is_editor_fully_empty(cx);
+                let editor_empty = message_editor.is_editor_fully_empty(cx);

-        if active_thread.is_empty() && editor_empty {
-            return None;
-        }
+                if active_thread.is_empty() && editor_empty {
+                    return None;
+                }

-        let thread = active_thread.thread().read(cx);
-        let is_generating = thread.is_generating();
-        let conversation_token_usage = thread.total_token_usage()?;
+                let thread = active_thread.thread().read(cx);
+                let is_generating = thread.is_generating();
+                let conversation_token_usage = thread.total_token_usage()?;

-        let (total_token_usage, is_estimating) =
-            if let Some((editing_message_id, unsent_tokens)) = active_thread.editing_message_id() {
-                let combined = thread
-                    .token_usage_up_to_message(editing_message_id)
-                    .add(unsent_tokens);
+                let (total_token_usage, is_estimating) =
+                    if let Some((editing_message_id, unsent_tokens)) =
+                        active_thread.editing_message_id()
+                    {
+                        let combined = thread
+                            .token_usage_up_to_message(editing_message_id)
+                            .add(unsent_tokens);

-                (combined, unsent_tokens > 0)
-            } else {
-                let unsent_tokens = message_editor.last_estimated_token_count().unwrap_or(0);
-                let combined = conversation_token_usage.add(unsent_tokens);
+                        (combined, unsent_tokens > 0)
+                    } else {
+                        let unsent_tokens =
+                            message_editor.last_estimated_token_count().unwrap_or(0);
+                        let combined = conversation_token_usage.add(unsent_tokens);

-                (combined, unsent_tokens > 0)
-            };
+                        (combined, unsent_tokens > 0)
+                    };

-        let is_waiting_to_update_token_count = message_editor.is_waiting_to_update_token_count();
+                let is_waiting_to_update_token_count =
+                    message_editor.is_waiting_to_update_token_count();

-        match &self.active_view {
-            ActiveView::Thread { .. } => {
                if total_token_usage.total == 0 {
                    return None;
                }
@@ -2915,6 +2914,21 @@ impl AgentPanel {
            .size(IconSize::Small)
            .color(Color::Error);

+        let retry_button = Button::new("retry", "Retry")
+            .icon(IconName::RotateCw)
+            .icon_position(IconPosition::Start)
+            .on_click({
+                let thread = thread.clone();
+                move |_, window, cx| {
+                    thread.update(cx, |thread, cx| {
+                        thread.clear_last_error();
+                        thread.thread().update(cx, |thread, cx| {
+                            thread.retry_last_completion(Some(window.window_handle()), cx);
+                        });
+                    });
+                }
+            });
+
        div()
            .border_t_1()
            .border_color(cx.theme().colors().border)
@@ -2923,13 +2937,72 @@ impl AgentPanel {
                    .icon(icon)
                    .title(header)
                    .description(message.clone())
-                    .primary_action(self.dismiss_error_button(thread, cx))
-                    .secondary_action(self.create_copy_button(message_with_header))
+                    .primary_action(retry_button)
+                    .secondary_action(self.dismiss_error_button(thread, cx))
+                    .tertiary_action(self.create_copy_button(message_with_header))
                    .bg_color(self.error_callout_bg(cx)),
            )
            .into_any_element()
    }

+    fn render_retryable_error(
+        &self,
+        message: SharedString,
+        can_enable_burn_mode: bool,
+        thread: &Entity<ActiveThread>,
+        cx: &mut Context<Self>,
+    ) -> AnyElement {
+        let icon = Icon::new(IconName::XCircle)
+            .size(IconSize::Small)
+            .color(Color::Error);
+
+        let retry_button = Button::new("retry", "Retry")
+            .icon(IconName::RotateCw)
+            .icon_position(IconPosition::Start)
+            .on_click({
+                let thread = thread.clone();
+                move |_, window, cx| {
+                    thread.update(cx, |thread, cx| {
+                        thread.clear_last_error();
+                        thread.thread().update(cx, |thread, cx| {
+                            thread.retry_last_completion(Some(window.window_handle()), cx);
+                        });
+                    });
+                }
+            });
+
+        let mut callout = Callout::new()
+            .icon(icon)
+            .title("Error")
+            .description(message.clone())
+            .bg_color(self.error_callout_bg(cx))
+            .primary_action(retry_button);
+
+        if can_enable_burn_mode {
+            let burn_mode_button = Button::new("enable_burn_retry", "Enable Burn Mode and Retry")
+                .icon(IconName::ZedBurnMode)
+                .icon_position(IconPosition::Start)
+                .on_click({
+                    let thread = thread.clone();
+                    move |_, window, cx| {
+                        thread.update(cx, |thread, cx| {
+                            thread.clear_last_error();
+                            thread.thread().update(cx, |thread, cx| {
+                                thread.enable_burn_mode_and_retry(Some(window.window_handle()), cx);
+                            });
+                        });
+                    }
+                });
+            callout = callout.secondary_action(burn_mode_button);
+        }
+
+        div()
+            .border_t_1()
+            .border_color(cx.theme().colors().border)
+            .child(callout)
+            .into_any_element()
+    }
+
    fn render_prompt_editor(
        &self,
        context_editor: &Entity<TextThreadEditor>,
@@ -3171,6 +3244,15 @@ impl Render for AgentPanel {
                                    ThreadError::Message { header, message } => {
                                        self.render_error_message(header, message, thread, cx)
                                    }
+                                    ThreadError::RetryableError {
+                                        message,
+                                        can_enable_burn_mode,
+                                    } => self.render_retryable_error(
+                                        message,
+                                        can_enable_burn_mode,
+                                        thread,
+                                        cx,
+                                    ),
                                })
                                .into_any(),
                        )
--- a/crates/assistant_tool/Cargo.toml
+++ b/crates/assistant_tool/Cargo.toml
@@ -40,6 +40,7 @@ collections = { workspace = true, features = ["test-support"] }
 clock = { workspace = true, features = ["test-support"] }
 ctor.workspace = true
 gpui = { workspace = true, features = ["test-support"] }
+indoc.workspace = true
 language = { workspace = true, features = ["test-support"] }
 language_model = { workspace = true, features = ["test-support"] }
 log.workspace = true
--- a/crates/assistant_tool/src/action_log.rs
+++ b/crates/assistant_tool/src/action_log.rs
@@ -8,7 +8,10 @@ use language::{Anchor, Buffer, BufferEvent, DiskState, Point, ToPoint};
 use project::{Project, ProjectItem, lsp_store::OpenLspBufferHandle};
 use std::{cmp, ops::Range, sync::Arc};
 use text::{Edit, Patch, Rope};
-use util::{RangeExt, ResultExt as _};
+use util::{
+    RangeExt, ResultExt as _,
+    paths::{PathStyle, RemotePathBuf},
+};

 /// Tracks actions performed by tools in a thread
 pub struct ActionLog {
@@ -18,8 +21,6 @@ pub struct ActionLog {
    edited_since_project_diagnostics_check: bool,
    /// The project this action log is associated with
    project: Entity<Project>,
-    /// Tracks which buffer versions have already been notified as changed externally
-    notified_versions: BTreeMap<Entity<Buffer>, clock::Global>,
 }

 impl ActionLog {
@@ -29,7 +30,6 @@ impl ActionLog {
            tracked_buffers: BTreeMap::default(),
            edited_since_project_diagnostics_check: false,
            project,
-            notified_versions: BTreeMap::default(),
        }
    }

@@ -51,6 +51,67 @@ impl ActionLog {
        Some(self.tracked_buffers.get(buffer)?.snapshot.clone())
    }

+    pub fn has_unnotified_user_edits(&self) -> bool {
+        self.tracked_buffers
+            .values()
+            .any(|tracked| tracked.has_unnotified_user_edits)
+    }
+
+    /// Return a unified diff patch with user edits made since last read or notification
+    pub fn unnotified_user_edits(&self, cx: &Context<Self>) -> Option<String> {
+        if !self.has_unnotified_user_edits() {
+            return None;
+        }
+
+        let unified_diff = self
+            .tracked_buffers
+            .values()
+            .filter_map(|tracked| {
+                if !tracked.has_unnotified_user_edits {
+                    return None;
+                }
+
+                let text_with_latest_user_edits = tracked.diff_base.to_string();
+                let text_with_last_seen_user_edits = tracked.last_seen_base.to_string();
+                if text_with_latest_user_edits == text_with_last_seen_user_edits {
+                    return None;
+                }
+                let patch = language::unified_diff(
+                    &text_with_last_seen_user_edits,
+                    &text_with_latest_user_edits,
+                );
+
+                let buffer = tracked.buffer.clone();
+                let file_path = buffer
+                    .read(cx)
+                    .file()
+                    .map(|file| RemotePathBuf::new(file.full_path(cx), PathStyle::Posix).to_proto())
+                    .unwrap_or_else(|| format!("buffer_{}", buffer.entity_id()));
+
+                let mut result = String::new();
+                result.push_str(&format!("--- a/{}\n", file_path));
+                result.push_str(&format!("+++ b/{}\n", file_path));
+                result.push_str(&patch);
+
+                Some(result)
+            })
+            .collect::<Vec<_>>()
+            .join("\n\n");
+
+        Some(unified_diff)
+    }
+
+    /// Return a unified diff patch with user edits made since last read/notification
+    /// and mark them as notified
+    pub fn flush_unnotified_user_edits(&mut self, cx: &Context<Self>) -> Option<String> {
+        let patch = self.unnotified_user_edits(cx);
+        self.tracked_buffers.values_mut().for_each(|tracked| {
+            tracked.has_unnotified_user_edits = false;
+            tracked.last_seen_base = tracked.diff_base.clone();
+        });
+        patch
+    }
+
    fn track_buffer_internal(
        &mut self,
        buffer: Entity<Buffer>,
@@ -59,7 +120,6 @@ impl ActionLog {
    ) -> &mut TrackedBuffer {
        let status = if is_created {
            if let Some(tracked) = self.tracked_buffers.remove(&buffer) {
-                self.notified_versions.remove(&buffer);
                match tracked.status {
                    TrackedBufferStatus::Created {
                        existing_file_content,
@@ -101,26 +161,31 @@ impl ActionLog {
                let diff = cx.new(|cx| BufferDiff::new(&text_snapshot, cx));
                let (diff_update_tx, diff_update_rx) = mpsc::unbounded();
                let diff_base;
+                let last_seen_base;
                let unreviewed_edits;
                if is_created {
                    diff_base = Rope::default();
+                    last_seen_base = Rope::default();
                    unreviewed_edits = Patch::new(vec![Edit {
                        old: 0..1,
                        new: 0..text_snapshot.max_point().row + 1,
                    }])
                } else {
                    diff_base = buffer.read(cx).as_rope().clone();
+                    last_seen_base = diff_base.clone();
                    unreviewed_edits = Patch::default();
                }
                TrackedBuffer {
                    buffer: buffer.clone(),
                    diff_base,
+                    last_seen_base,
                    unreviewed_edits,
                    snapshot: text_snapshot.clone(),
                    status,
                    version: buffer.read(cx).version(),
                    diff,
                    diff_update: diff_update_tx,
+                    has_unnotified_user_edits: false,
                    _open_lsp_handle: open_lsp_handle,
                    _maintain_diff: cx.spawn({
                        let buffer = buffer.clone();
@@ -174,7 +239,6 @@ impl ActionLog {
                    // If the buffer had been edited by a tool, but it got
                    // deleted externally, we want to stop tracking it.
                    self.tracked_buffers.remove(&buffer);
-                    self.notified_versions.remove(&buffer);
                }
                cx.notify();
            }
@@ -188,7 +252,6 @@ impl ActionLog {
                    // resurrected externally, we want to clear the edits we
                    // were tracking and reset the buffer's state.
                    self.tracked_buffers.remove(&buffer);
-                    self.notified_versions.remove(&buffer);
                    self.track_buffer_internal(buffer, false, cx);
                }
                cx.notify();
@@ -262,19 +325,23 @@ impl ActionLog {
        buffer_snapshot: text::BufferSnapshot,
        cx: &mut AsyncApp,
    ) -> Result<()> {
-        let rebase = this.read_with(cx, |this, cx| {
+        let rebase = this.update(cx, |this, cx| {
            let tracked_buffer = this
                .tracked_buffers
-                .get(buffer)
+                .get_mut(buffer)
                .context("buffer not tracked")?;

+            if let ChangeAuthor::User = author {
+                tracked_buffer.has_unnotified_user_edits = true;
+            }
+
            let rebase = cx.background_spawn({
                let mut base_text = tracked_buffer.diff_base.clone();
                let old_snapshot = tracked_buffer.snapshot.clone();
                let new_snapshot = buffer_snapshot.clone();
                let unreviewed_edits = tracked_buffer.unreviewed_edits.clone();
+                let edits = diff_snapshots(&old_snapshot, &new_snapshot);
                async move {
-                    let edits = diff_snapshots(&old_snapshot, &new_snapshot);
                    if let ChangeAuthor::User = author {
                        apply_non_conflicting_edits(
                            &unreviewed_edits,
@@ -494,7 +561,6 @@ impl ActionLog {
        match tracked_buffer.status {
            TrackedBufferStatus::Created { .. } => {
                self.tracked_buffers.remove(&buffer);
-                self.notified_versions.remove(&buffer);
                cx.notify();
            }
            TrackedBufferStatus::Modified => {
@@ -520,7 +586,6 @@ impl ActionLog {
        match tracked_buffer.status {
            TrackedBufferStatus::Deleted => {
                self.tracked_buffers.remove(&buffer);
-                self.notified_versions.remove(&buffer);
                cx.notify();
            }
            _ => {
@@ -629,7 +694,6 @@ impl ActionLog {
                };

                self.tracked_buffers.remove(&buffer);
-                self.notified_versions.remove(&buffer);
                cx.notify();
                task
            }
@@ -643,7 +707,6 @@ impl ActionLog {

                // Clear all tracked edits for this buffer and start over as if we just read it.
                self.tracked_buffers.remove(&buffer);
-                self.notified_versions.remove(&buffer);
                self.buffer_read(buffer.clone(), cx);
                cx.notify();
                save
@@ -744,33 +807,6 @@ impl ActionLog {
            .collect()
    }

-    /// Returns stale buffers that haven't been notified yet
-    pub fn unnotified_stale_buffers<'a>(
-        &'a self,
-        cx: &'a App,
-    ) -> impl Iterator<Item = &'a Entity<Buffer>> {
-        self.stale_buffers(cx).filter(|buffer| {
-            let buffer_entity = buffer.read(cx);
-            self.notified_versions
-                .get(buffer)
-                .map_or(true, |notified_version| {
-                    *notified_version != buffer_entity.version
-                })
-        })
-    }
-
-    /// Marks the given buffers as notified at their current versions
-    pub fn mark_buffers_as_notified(
-        &mut self,
-        buffers: impl IntoIterator<Item = Entity<Buffer>>,
-        cx: &App,
-    ) {
-        for buffer in buffers {
-            let version = buffer.read(cx).version.clone();
-            self.notified_versions.insert(buffer, version);
-        }
-    }
-
    /// Iterate over buffers changed since last read or edited by the model
    pub fn stale_buffers<'a>(&'a self, cx: &'a App) -> impl Iterator<Item = &'a Entity<Buffer>> {
        self.tracked_buffers
@@ -914,12 +950,14 @@ enum TrackedBufferStatus {
 struct TrackedBuffer {
    buffer: Entity<Buffer>,
    diff_base: Rope,
+    last_seen_base: Rope,
    unreviewed_edits: Patch<u32>,
    status: TrackedBufferStatus,
    version: clock::Global,
    diff: Entity<BufferDiff>,
    snapshot: text::BufferSnapshot,
    diff_update: mpsc::UnboundedSender<(ChangeAuthor, text::BufferSnapshot)>,
+    has_unnotified_user_edits: bool,
    _open_lsp_handle: OpenLspBufferHandle,
    _maintain_diff: Task<()>,
    _subscription: Subscription,
@@ -950,6 +988,7 @@ mod tests {
    use super::*;
    use buffer_diff::DiffHunkStatusKind;
    use gpui::TestAppContext;
+    use indoc::indoc;
    use language::Point;
    use project::{FakeFs, Fs, Project, RemoveOptions};
    use rand::prelude::*;
@@ -1232,6 +1271,110 @@ mod tests {
        assert_eq!(unreviewed_hunks(&action_log, cx), vec![]);
    }

+    #[gpui::test(iterations = 10)]
+    async fn test_user_edits_notifications(cx: &mut TestAppContext) {
+        init_test(cx);
+
+        let fs = FakeFs::new(cx.executor());
+        fs.insert_tree(
+            path!("/dir"),
+            json!({"file": indoc! {"
+            abc
+            def
+            ghi
+            jkl
+            mno"}}),
+        )
+        .await;
+        let project = Project::test(fs.clone(), [path!("/dir").as_ref()], cx).await;
+        let action_log = cx.new(|_| ActionLog::new(project.clone()));
+        let file_path = project
+            .read_with(cx, |project, cx| project.find_project_path("dir/file", cx))
+            .unwrap();
+        let buffer = project
+            .update(cx, |project, cx| project.open_buffer(file_path, cx))
+            .await
+            .unwrap();
+
+        // Agent edits
+        cx.update(|cx| {
+            action_log.update(cx, |log, cx| log.buffer_read(buffer.clone(), cx));
+            buffer.update(cx, |buffer, cx| {
+                buffer
+                    .edit([(Point::new(1, 2)..Point::new(2, 3), "F\nGHI")], None, cx)
+                    .unwrap()
+            });
+            action_log.update(cx, |log, cx| log.buffer_edited(buffer.clone(), cx));
+        });
+        cx.run_until_parked();
+        assert_eq!(
+            buffer.read_with(cx, |buffer, _| buffer.text()),
+            indoc! {"
+                abc
+                deF
+                GHI
+                jkl
+                mno"}
+        );
+        assert_eq!(
+            unreviewed_hunks(&action_log, cx),
+            vec![(
+                buffer.clone(),
+                vec![HunkStatus {
+                    range: Point::new(1, 0)..Point::new(3, 0),
+                    diff_status: DiffHunkStatusKind::Modified,
+                    old_text: "def\nghi\n".into(),
+                }],
+            )]
+        );
+
+        // User edits
+        buffer.update(cx, |buffer, cx| {
+            buffer.edit(
+                [
+                    (Point::new(0, 2)..Point::new(0, 2), "X"),
+                    (Point::new(3, 0)..Point::new(3, 0), "Y"),
+                ],
+                None,
+                cx,
+            )
+        });
+        cx.run_until_parked();
+        assert_eq!(
+            buffer.read_with(cx, |buffer, _| buffer.text()),
+            indoc! {"
+                abXc
+                deF
+                GHI
+                Yjkl
+                mno"}
+        );
+
+        // User edits should be stored separately from agent's
+        let user_edits = action_log.update(cx, |log, cx| log.unnotified_user_edits(cx));
+        assert_eq!(
+            user_edits.expect("should have some user edits"),
+            indoc! {"
+                --- a/dir/file
+                +++ b/dir/file
+                @@ -1,5 +1,5 @@
+                -abc
+                +abXc
+                 def
+                 ghi
+                -jkl
+                +Yjkl
+                 mno
+            "}
+        );
+
+        action_log.update(cx, |log, cx| {
+            log.keep_edits_in_range(buffer.clone(), Point::new(0, 0)..Point::new(1, 0), cx)
+        });
+        cx.run_until_parked();
+        assert_eq!(unreviewed_hunks(&action_log, cx), vec![]);
+    }
+
    #[gpui::test(iterations = 10)]
    async fn test_creating_files(cx: &mut TestAppContext) {
        init_test(cx);
@@ -2221,4 +2364,61 @@ mod tests {
                .collect()
        })
    }
+
+    #[gpui::test]
+    async fn test_format_patch(cx: &mut TestAppContext) {
+        init_test(cx);
+
+        let fs = FakeFs::new(cx.executor());
+        fs.insert_tree(
+            path!("/dir"),
+            json!({"test.txt": "line 1\nline 2\nline 3\n"}),
+        )
+        .await;
+        let project = Project::test(fs.clone(), [path!("/dir").as_ref()], cx).await;
+        let action_log = cx.new(|_| ActionLog::new(project.clone()));
+
+        let file_path = project
+            .read_with(cx, |project, cx| {
+                project.find_project_path("dir/test.txt", cx)
+            })
+            .unwrap();
+        let buffer = project
+            .update(cx, |project, cx| project.open_buffer(file_path, cx))
+            .await
+            .unwrap();
+
+        cx.update(|cx| {
+            // Track the buffer and mark it as read first
+            action_log.update(cx, |log, cx| {
+                log.buffer_read(buffer.clone(), cx);
+            });
+
+            // Make some edits to create a patch
+            buffer.update(cx, |buffer, cx| {
+                buffer
+                    .edit([(Point::new(1, 0)..Point::new(1, 6), "CHANGED")], None, cx)
+                    .unwrap(); // Replace "line2" with "CHANGED"
+            });
+        });
+
+        cx.run_until_parked();
+
+        // Get the patch
+        let patch = action_log.update(cx, |log, cx| log.unnotified_user_edits(cx));
+
+        // Verify the patch format contains expected unified diff elements
+        assert_eq!(
+            patch.unwrap(),
+            indoc! {"
+            --- a/dir/test.txt
+            +++ b/dir/test.txt
+            @@ -1,3 +1,3 @@
+             line 1
+            -line 2
+            +CHANGED
+             line 3
+            "}
+        );
+    }
 }
--- a/crates/assistant_tools/Cargo.toml
+++ b/crates/assistant_tools/Cargo.toml
@@ -63,6 +63,7 @@ which.workspace = true
 workspace-hack.workspace = true
 workspace.workspace = true
 zed_llm_client.workspace = true
+diffy = "0.4.2"

 [dev-dependencies]
 lsp = { workspace = true, features = ["test-support"] }
--- a/crates/assistant_tools/src/edit_agent/evals.rs
+++ b/crates/assistant_tools/src/edit_agent/evals.rs
@@ -12,6 +12,7 @@ use collections::HashMap;
 use fs::FakeFs;
 use futures::{FutureExt, future::LocalBoxFuture};
 use gpui::{AppContext, TestAppContext, Timer};
+use http_client::StatusCode;
 use indoc::{formatdoc, indoc};
 use language_model::{
    LanguageModelRegistry, LanguageModelRequestTool, LanguageModelToolResult,
@@ -1675,6 +1676,30 @@ async fn retry_on_rate_limit<R>(mut request: impl AsyncFnMut() -> Result<R>) ->
                        Timer::after(retry_after + jitter).await;
                        continue;
                    }
+                    LanguageModelCompletionError::UpstreamProviderError {
+                        status,
+                        retry_after,
+                        ..
+                    } => {
+                        // Only retry for specific status codes
+                        let should_retry = matches!(
+                            *status,
+                            StatusCode::TOO_MANY_REQUESTS | StatusCode::SERVICE_UNAVAILABLE
+                        ) || status.as_u16() == 529;
+
+                        if !should_retry {
+                            return Err(err.into());
+                        }
+
+                        // Use server-provided retry_after if available, otherwise use default
+                        let retry_after = retry_after.unwrap_or(Duration::from_secs(5));
+                        let jitter = retry_after.mul_f64(rand::thread_rng().gen_range(0.0..1.0));
+                        eprintln!(
+                            "Attempt #{attempt}: {err}. Retry after {retry_after:?} + jitter of {jitter:?}"
+                        );
+                        Timer::after(retry_after + jitter).await;
+                        continue;
+                    }
                    _ => return Err(err.into()),
                },
                Err(err) => return Err(err),
--- a/crates/assistant_tools/src/project_notifications_tool.rs
+++ b/crates/assistant_tools/src/project_notifications_tool.rs
@@ -6,8 +6,7 @@ use language_model::{LanguageModel, LanguageModelRequest, LanguageModelToolSchem
 use project::Project;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
-use std::fmt::Write as _;
-use std::sync::Arc;
+use std::{fmt::Write, sync::Arc};
 use ui::IconName;

 #[derive(Debug, Serialize, Deserialize, JsonSchema)]
@@ -52,39 +51,113 @@ impl Tool for ProjectNotificationsTool {
        _window: Option<AnyWindowHandle>,
        cx: &mut App,
    ) -> ToolResult {
-        let mut stale_files = String::new();
-        let mut notified_buffers = Vec::new();
-
-        for stale_file in action_log.read(cx).unnotified_stale_buffers(cx) {
-            if let Some(file) = stale_file.read(cx).file() {
-                writeln!(&mut stale_files, "- {}", file.path().display()).ok();
-                notified_buffers.push(stale_file.clone());
-            }
-        }
-
-        if !notified_buffers.is_empty() {
-            action_log.update(cx, |log, cx| {
-                log.mark_buffers_as_notified(notified_buffers, cx);
-            });
-        }
-
-        let response = if stale_files.is_empty() {
-            "No new notifications".to_string()
-        } else {
-            // NOTE: Changes to this prompt require a symmetric update in the LLM Worker
-            const HEADER: &str = include_str!("./project_notifications_tool/prompt_header.txt");
-            format!("{HEADER}{stale_files}").replace("\r\n", "\n")
+        let Some(user_edits_diff) =
+            action_log.update(cx, |log, cx| log.flush_unnotified_user_edits(cx))
+        else {
+            return result("No new notifications");
        };

-        Task::ready(Ok(response.into())).into()
+        // NOTE: Changes to this prompt require a symmetric update in the LLM Worker
+        const HEADER: &str = include_str!("./project_notifications_tool/prompt_header.txt");
+        const MAX_BYTES: usize = 8000;
+        let diff = fit_patch_to_size(&user_edits_diff, MAX_BYTES);
+        result(&format!("{HEADER}\n\n```diff\n{diff}\n```\n").replace("\r\n", "\n"))
    }
 }

+fn result(response: &str) -> ToolResult {
+    Task::ready(Ok(response.to_string().into())).into()
+}
+
+/// Make sure that the patch fits into the size limit (in bytes).
+/// Compress the patch by omitting some parts if needed.
+/// Unified diff format is assumed.
+fn fit_patch_to_size(patch: &str, max_size: usize) -> String {
+    if patch.len() <= max_size {
+        return patch.to_string();
+    }
+
+    // Compression level 1: remove context lines in diff bodies, but
+    // leave the counts and positions of inserted/deleted lines
+    let mut current_size = patch.len();
+    let mut file_patches = split_patch(&patch);
+    file_patches.sort_by_key(|patch| patch.len());
+    let compressed_patches = file_patches
+        .iter()
+        .rev()
+        .map(|patch| {
+            if current_size > max_size {
+                let compressed = compress_patch(patch).unwrap_or_else(|_| patch.to_string());
+                current_size -= patch.len() - compressed.len();
+                compressed
+            } else {
+                patch.to_string()
+            }
+        })
+        .collect::<Vec<_>>();
+
+    if current_size <= max_size {
+        return compressed_patches.join("\n\n");
+    }
+
+    // Compression level 2: list paths of the changed files only
+    let filenames = file_patches
+        .iter()
+        .map(|patch| {
+            let patch = diffy::Patch::from_str(patch).unwrap();
+            let path = patch
+                .modified()
+                .and_then(|path| path.strip_prefix("b/"))
+                .unwrap_or_default();
+            format!("- {path}\n")
+        })
+        .collect::<Vec<_>>();
+
+    filenames.join("")
+}
+
+/// Split a potentially multi-file patch into multiple single-file patches
+fn split_patch(patch: &str) -> Vec<String> {
+    let mut result = Vec::new();
+    let mut current_patch = String::new();
+
+    for line in patch.lines() {
+        if line.starts_with("---") && !current_patch.is_empty() {
+            result.push(current_patch.trim_end_matches('\n').into());
+            current_patch = String::new();
+        }
+        current_patch.push_str(line);
+        current_patch.push('\n');
+    }
+
+    if !current_patch.is_empty() {
+        result.push(current_patch.trim_end_matches('\n').into());
+    }
+
+    result
+}
+
+fn compress_patch(patch: &str) -> anyhow::Result<String> {
+    let patch = diffy::Patch::from_str(patch)?;
+    let mut out = String::new();
+
+    writeln!(out, "--- {}", patch.original().unwrap_or("a"))?;
+    writeln!(out, "+++ {}", patch.modified().unwrap_or("b"))?;
+
+    for hunk in patch.hunks() {
+        writeln!(out, "@@ -{} +{} @@", hunk.old_range(), hunk.new_range())?;
+        writeln!(out, "[...skipped...]")?;
+    }
+
+    Ok(out)
+}
+
 #[cfg(test)]
 mod tests {
    use super::*;
    use assistant_tool::ToolResultContent;
    use gpui::{AppContext, TestAppContext};
+    use indoc::indoc;
    use language_model::{LanguageModelRequest, fake_provider::FakeLanguageModelProvider};
    use project::{FakeFs, Project};
    use serde_json::json;
@@ -123,6 +196,7 @@ mod tests {
        action_log.update(cx, |log, cx| {
            log.buffer_read(buffer.clone(), cx);
        });
+        cx.run_until_parked();

        // Run the tool before any changes
        let tool = Arc::new(ProjectNotificationsTool);
@@ -142,6 +216,7 @@ mod tests {
                cx,
            )
        });
+        cx.run_until_parked();

        let response = result.output.await.unwrap();
        let response_text = match &response.content {
@@ -158,6 +233,7 @@ mod tests {
        buffer.update(cx, |buffer, cx| {
            buffer.edit([(1..1, "\nChange!\n")], None, cx);
        });
+        cx.run_until_parked();

        // Run the tool again
        let result = cx.update(|cx| {
@@ -171,6 +247,7 @@ mod tests {
                cx,
            )
        });
+        cx.run_until_parked();

        // This time the buffer is stale, so the tool should return a notification
        let response = result.output.await.unwrap();
@@ -179,10 +256,12 @@ mod tests {
            _ => panic!("Expected text response"),
        };

-        let expected_content = "[The following is an auto-generated notification; do not reply]\n\nThese files have changed since the last read:\n- code.rs\n";
-        assert_eq!(
-            response_text.as_str(),
-            expected_content,
+        assert!(
+            response_text.contains("These files have changed"),
+            "Tool should return the stale buffer notification"
+        );
+        assert!(
+            response_text.contains("test/code.rs"),
            "Tool should return the stale buffer notification"
        );

@@ -198,6 +277,7 @@ mod tests {
                cx,
            )
        });
+        cx.run_until_parked();

        let response = result.output.await.unwrap();
        let response_text = match &response.content {
@@ -212,6 +292,61 @@ mod tests {
        );
    }

+    #[test]
+    fn test_patch_compression() {
+        // Given a patch that doesn't fit into the size budget
+        let patch = indoc! {"
+       --- a/dir/test.txt
+       +++ b/dir/test.txt
+       @@ -1,3 +1,3 @@
+        line 1
+       -line 2
+       +CHANGED
+        line 3
+       @@ -10,2 +10,2 @@
+        line 10
+       -line 11
+       +line eleven
+
+
+       --- a/dir/another.txt
+       +++ b/dir/another.txt
+       @@ -100,1 +1,1 @@
+       -before
+       +after
+       "};
+
+        // When the size deficit can be compensated by dropping the body,
+        // then the body should be trimmed for larger files first
+        let limit = patch.len() - 10;
+        let compressed = fit_patch_to_size(patch, limit);
+        let expected = indoc! {"
+       --- a/dir/test.txt
+       +++ b/dir/test.txt
+       @@ -1,3 +1,3 @@
+       [...skipped...]
+       @@ -10,2 +10,2 @@
+       [...skipped...]
+
+
+       --- a/dir/another.txt
+       +++ b/dir/another.txt
+       @@ -100,1 +1,1 @@
+       -before
+       +after"};
+        assert_eq!(compressed, expected);
+
+        // When the size deficit is too large, then only file paths
+        // should be returned
+        let limit = 10;
+        let compressed = fit_patch_to_size(patch, limit);
+        let expected = indoc! {"
+       - dir/another.txt
+       - dir/test.txt
+       "};
+        assert_eq!(compressed, expected);
+    }
+
    fn init_test(cx: &mut TestAppContext) {
        cx.update(|cx| {
            let settings_store = SettingsStore::test(cx);
--- a/crates/assistant_tools/src/read_file_tool.rs
+++ b/crates/assistant_tools/src/read_file_tool.rs
@@ -285,7 +285,10 @@ impl Tool for ReadFileTool {

                        Using the line numbers in this outline, you can call this tool again
                        while specifying the start_line and end_line fields to see the
-                        implementations of symbols in the outline."
+                        implementations of symbols in the outline.
+                        
+                        Alternatively, you can fall back to the `grep` tool (if available)
+                        to search the file for specific content."
                    }
                    .into())
                }
--- a/crates/collab/src/api/billing.rs
+++ b/crates/collab/src/api/billing.rs
@@ -1,4 +1,5 @@
 use anyhow::{Context as _, bail};
+use axum::routing::put;
 use axum::{
    Extension, Json, Router,
    extract::{self, Query},
@@ -27,8 +28,8 @@ use crate::api::events::SnowflakeRow;
 use crate::db::billing_subscription::{
    StripeCancellationReason, StripeSubscriptionStatus, SubscriptionKind,
 };
+use crate::llm::AGENT_EXTENDED_TRIAL_FEATURE_FLAG;
 use crate::llm::db::subscription_usage_meter::{self, CompletionMode};
-use crate::llm::{AGENT_EXTENDED_TRIAL_FEATURE_FLAG, DEFAULT_MAX_MONTHLY_SPEND};
 use crate::rpc::{ResultExt as _, Server};
 use crate::stripe_client::{
    StripeCancellationDetailsReason, StripeClient, StripeCustomerId, StripeSubscription,
@@ -47,10 +48,7 @@ use crate::{

 pub fn router() -> Router {
    Router::new()
-        .route(
-            "/billing/preferences",
-            get(get_billing_preferences).put(update_billing_preferences),
-        )
+        .route("/billing/preferences", put(update_billing_preferences))
        .route(
            "/billing/subscriptions",
            get(list_billing_subscriptions).post(create_billing_subscription),
@@ -66,11 +64,6 @@ pub fn router() -> Router {
        .route("/billing/usage", get(get_current_usage))
 }

-#[derive(Debug, Deserialize)]
-struct GetBillingPreferencesParams {
-    github_user_id: i32,
-}
-
 #[derive(Debug, Serialize)]
 struct BillingPreferencesResponse {
    trial_started_at: Option<String>,
@@ -79,43 +72,6 @@ struct BillingPreferencesResponse {
    model_request_overages_spend_limit_in_cents: i32,
 }

-async fn get_billing_preferences(
-    Extension(app): Extension<Arc<AppState>>,
-    Query(params): Query<GetBillingPreferencesParams>,
-) -> Result<Json<BillingPreferencesResponse>> {
-    let user = app
-        .db
-        .get_user_by_github_user_id(params.github_user_id)
-        .await?
-        .context("user not found")?;
-
-    let billing_customer = app.db.get_billing_customer_by_user_id(user.id).await?;
-    let preferences = app.db.get_billing_preferences(user.id).await?;
-
-    Ok(Json(BillingPreferencesResponse {
-        trial_started_at: billing_customer
-            .and_then(|billing_customer| billing_customer.trial_started_at)
-            .map(|trial_started_at| {
-                trial_started_at
-                    .and_utc()
-                    .to_rfc3339_opts(SecondsFormat::Millis, true)
-            }),
-        max_monthly_llm_usage_spending_in_cents: preferences
-            .as_ref()
-            .map_or(DEFAULT_MAX_MONTHLY_SPEND.0 as i32, |preferences| {
-                preferences.max_monthly_llm_usage_spending_in_cents
-            }),
-        model_request_overages_enabled: preferences.as_ref().map_or(false, |preferences| {
-            preferences.model_request_overages_enabled
-        }),
-        model_request_overages_spend_limit_in_cents: preferences
-            .as_ref()
-            .map_or(0, |preferences| {
-                preferences.model_request_overages_spend_limit_in_cents
-            }),
-    }))
-}
-
 #[derive(Debug, Deserialize)]
 struct UpdateBillingPreferencesBody {
    github_user_id: i32,
--- a/crates/collab/src/cents.rs
+++ b/crates/collab/src/cents.rs
@@ -1,83 +0,0 @@
-use serde::Serialize;
-
-/// A number of cents.
-#[derive(
-    Debug,
-    PartialEq,
-    Eq,
-    PartialOrd,
-    Ord,
-    Hash,
-    Clone,
-    Copy,
-    derive_more::Add,
-    derive_more::AddAssign,
-    derive_more::Sub,
-    derive_more::SubAssign,
-    Serialize,
-)]
-pub struct Cents(pub u32);
-
-impl Cents {
-    pub const ZERO: Self = Self(0);
-
-    pub const fn new(cents: u32) -> Self {
-        Self(cents)
-    }
-
-    pub const fn from_dollars(dollars: u32) -> Self {
-        Self(dollars * 100)
-    }
-
-    pub fn saturating_sub(self, other: Cents) -> Self {
-        Self(self.0.saturating_sub(other.0))
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use pretty_assertions::assert_eq;
-
-    use super::*;
-
-    #[test]
-    fn test_cents_new() {
-        assert_eq!(Cents::new(50), Cents(50));
-    }
-
-    #[test]
-    fn test_cents_from_dollars() {
-        assert_eq!(Cents::from_dollars(1), Cents(100));
-        assert_eq!(Cents::from_dollars(5), Cents(500));
-    }
-
-    #[test]
-    fn test_cents_zero() {
-        assert_eq!(Cents::ZERO, Cents(0));
-    }
-
-    #[test]
-    fn test_cents_add() {
-        assert_eq!(Cents(50) + Cents(30), Cents(80));
-    }
-
-    #[test]
-    fn test_cents_add_assign() {
-        let mut cents = Cents(50);
-        cents += Cents(30);
-        assert_eq!(cents, Cents(80));
-    }
-
-    #[test]
-    fn test_cents_saturating_sub() {
-        assert_eq!(Cents(50).saturating_sub(Cents(30)), Cents(20));
-        assert_eq!(Cents(30).saturating_sub(Cents(50)), Cents(0));
-    }
-
-    #[test]
-    fn test_cents_ordering() {
-        assert!(Cents(50) > Cents(30));
-        assert!(Cents(30) < Cents(50));
-        assert_eq!(Cents(50), Cents(50));
-    }
-}
--- a/crates/collab/src/lib.rs
+++ b/crates/collab/src/lib.rs
@@ -1,6 +1,5 @@
 pub mod api;
 pub mod auth;
-mod cents;
 pub mod db;
 pub mod env;
 pub mod executor;
@@ -21,7 +20,6 @@ use axum::{
    http::{HeaderMap, StatusCode},
    response::IntoResponse,
 };
-pub use cents::*;
 use db::{ChannelId, Database};
 use executor::Executor;
 use llm::db::LlmDatabase;
--- a/crates/collab/src/llm.rs
+++ b/crates/collab/src/llm.rs
@@ -1,8 +1,6 @@
 pub mod db;
 mod token;

-use crate::Cents;
-
 pub use token::*;

 pub const AGENT_EXTENDED_TRIAL_FEATURE_FLAG: &str = "agent-extended-trial";
@@ -12,9 +10,3 @@ pub const BYPASS_ACCOUNT_AGE_CHECK_FEATURE_FLAG: &str = "bypass-account-age-chec

 /// The minimum account age an account must have in order to use the LLM service.
 pub const MIN_ACCOUNT_AGE_FOR_LLM_USE: chrono::Duration = chrono::Duration::days(30);
-
-/// The default value to use for maximum spend per month if the user did not
-/// explicitly set a maximum spend.
-///
-/// Used to prevent surprise bills.
-pub const DEFAULT_MAX_MONTHLY_SPEND: Cents = Cents::from_dollars(10);
--- a/crates/component/src/component_layout.rs
+++ b/crates/component/src/component_layout.rs
@@ -48,20 +48,20 @@ impl RenderOnce for ComponentExample {
            )
            .child(
                div()
-                    .flex()
-                    .w_full()
-                    .rounded_xl()
                    .min_h(px(100.))
-                    .justify_center()
+                    .w_full()
                    .p_8()
+                    .flex()
+                    .items_center()
+                    .justify_center()
+                    .rounded_xl()
                    .border_1()
                    .border_color(cx.theme().colors().border.opacity(0.5))
                    .bg(pattern_slash(
-                        cx.theme().colors().surface_background.opacity(0.5),
+                        cx.theme().colors().surface_background.opacity(0.25),
                        12.0,
                        12.0,
                    ))
-                    .shadow_xs()
                    .child(self.element),
            )
            .into_any_element()
--- a/crates/dap_adapters/src/javascript.rs
+++ b/crates/dap_adapters/src/javascript.rs
@@ -54,20 +54,6 @@ impl JsDebugAdapter {
        user_args: Option<Vec<String>>,
        _: &mut AsyncApp,
    ) -> Result<DebugAdapterBinary> {
-        let adapter_path = if let Some(user_installed_path) = user_installed_path {
-            user_installed_path
-        } else {
-            let adapter_path = paths::debug_adapters_dir().join(self.name().as_ref());
-
-            let file_name_prefix = format!("{}_", self.name());
-
-            util::fs::find_file_name_in_dir(adapter_path.as_path(), |file_name| {
-                file_name.starts_with(&file_name_prefix)
-            })
-            .await
-            .context("Couldn't find JavaScript dap directory")?
-        };
-
        let tcp_connection = task_definition.tcp_connection.clone().unwrap_or_default();
        let (host, port, timeout) = crate::configure_tcp_connection(tcp_connection).await?;

@@ -136,21 +122,27 @@ impl JsDebugAdapter {
                .or_insert(true.into());
        }

+        let adapter_path = if let Some(user_installed_path) = user_installed_path {
+            user_installed_path
+        } else {
+            let adapter_path = paths::debug_adapters_dir().join(self.name().as_ref());
+
+            let file_name_prefix = format!("{}_", self.name());
+
+            util::fs::find_file_name_in_dir(adapter_path.as_path(), |file_name| {
+                file_name.starts_with(&file_name_prefix)
+            })
+            .await
+            .context("Couldn't find JavaScript dap directory")?
+            .join(Self::ADAPTER_PATH)
+        };
+
        let arguments = if let Some(mut args) = user_args {
-            args.insert(
-                0,
-                adapter_path
-                    .join(Self::ADAPTER_PATH)
-                    .to_string_lossy()
-                    .to_string(),
-            );
+            args.insert(0, adapter_path.to_string_lossy().to_string());
            args
        } else {
            vec![
-                adapter_path
-                    .join(Self::ADAPTER_PATH)
-                    .to_string_lossy()
-                    .to_string(),
+                adapter_path.to_string_lossy().to_string(),
                port.to_string(),
                host.to_string(),
            ]
--- a/crates/dap_adapters/src/python.rs
+++ b/crates/dap_adapters/src/python.rs
@@ -40,12 +40,7 @@ impl PythonDebugAdapter {
                "Using user-installed debugpy adapter from: {}",
                user_installed_path.display()
            );
-            vec![
-                user_installed_path
-                    .join(Self::ADAPTER_PATH)
-                    .to_string_lossy()
-                    .to_string(),
-            ]
+            vec![user_installed_path.to_string_lossy().to_string()]
        } else if installed_in_venv {
            log::debug!("Using venv-installed debugpy");
            vec!["-m".to_string(), "debugpy.adapter".to_string()]
@@ -700,7 +695,7 @@ mod tests {
        let port = 5678;

        // Case 1: User-defined debugpy path (highest precedence)
-        let user_path = PathBuf::from("/custom/path/to/debugpy");
+        let user_path = PathBuf::from("/custom/path/to/debugpy/src/debugpy/adapter");
        let user_args = PythonDebugAdapter::generate_debugpy_arguments(
            &host,
            port,
@@ -717,7 +712,7 @@ mod tests {
                .await
                .unwrap();

-        assert!(user_args[0].ends_with("src/debugpy/adapter"));
+        assert_eq!(user_args[0], "/custom/path/to/debugpy/src/debugpy/adapter");
        assert_eq!(user_args[1], "--host=127.0.0.1");
        assert_eq!(user_args[2], "--port=5678");

--- a/crates/debugger_ui/src/debugger_panel.rs
+++ b/crates/debugger_ui/src/debugger_panel.rs
@@ -1760,6 +1760,7 @@ impl Render for DebugPanel {
                                        category_filter: Some(
                                            zed_actions::ExtensionCategoryFilter::DebugAdapters,
                                        ),
+                                        id: None,
                                    }
                                    .boxed_clone(),
                                    cx,
--- a/crates/debugger_ui/src/new_process_modal.rs
+++ b/crates/debugger_ui/src/new_process_modal.rs
@@ -766,14 +766,7 @@ impl Render for NewProcessModal {
                            ))
                            .child(
                                h_flex()
-                                    .child(div().child(self.adapter_drop_down_menu(window, cx)))
-                                    .child(
-                                        Button::new("debugger-spawn", "Start")
-                                            .on_click(cx.listener(|this, _, window, cx| {
-                                                this.start_new_session(window, cx)
-                                            }))
-                                            .disabled(disabled),
-                                    ),
+                                    .child(div().child(self.adapter_drop_down_menu(window, cx))),
                            )
                    }),
                    NewProcessMode::Debug => el,
--- a/crates/debugger_ui/src/session/running/memory_view.rs
+++ b/crates/debugger_ui/src/session/running/memory_view.rs
@@ -8,10 +8,10 @@ use std::{

 use editor::{Editor, EditorElement, EditorStyle};
 use gpui::{
-    Action, AppContext, DismissEvent, Empty, Entity, FocusHandle, Focusable, MouseButton,
-    MouseMoveEvent, Point, ScrollStrategy, ScrollWheelEvent, Stateful, Subscription, Task,
-    TextStyle, UniformList, UniformListScrollHandle, WeakEntity, actions, anchored, bounds,
-    deferred, point, size, uniform_list,
+    Action, AppContext, DismissEvent, DragMoveEvent, Empty, Entity, FocusHandle, Focusable,
+    MouseButton, Point, ScrollStrategy, ScrollWheelEvent, Stateful, Subscription, Task, TextStyle,
+    UniformList, UniformListScrollHandle, WeakEntity, actions, anchored, deferred, point,
+    uniform_list,
 };
 use notifications::status_toast::{StatusToast, ToastIcon};
 use project::debugger::{MemoryCell, dap_command::DataBreakpointContext, session::Session};
@@ -126,6 +126,8 @@ impl ViewState {
    }
 }

+struct ScrollbarDragging;
+
 static HEX_BYTES_MEMOIZED: LazyLock<[SharedString; 256]> =
    LazyLock::new(|| std::array::from_fn(|byte| SharedString::from(format!("{byte:02X}"))));
 static UNKNOWN_BYTE: SharedString = SharedString::new_static("??");
@@ -159,6 +161,11 @@ impl MemoryView {
            open_context_menu: None,
        };
        this.change_query_bar_mode(false, window, cx);
+        cx.on_focus_out(&this.focus_handle, window, |this, _, window, cx| {
+            this.change_query_bar_mode(false, window, cx);
+            cx.notify();
+        })
+        .detach();
        this
    }
    fn hide_scrollbar(&mut self, window: &mut Window, cx: &mut Context<Self>) {
@@ -184,11 +191,14 @@ impl MemoryView {
            div()
                .occlude()
                .id("memory-view-vertical-scrollbar")
-                .on_mouse_move(cx.listener(|this, evt, _, cx| {
-                    this.handle_drag(evt);
+                .on_drag_move(cx.listener(|this, evt, _, cx| {
+                    let did_handle = this.handle_scroll_drag(evt);
                    cx.notify();
-                    cx.stop_propagation()
+                    if did_handle {
+                        cx.stop_propagation()
+                    }
                }))
+                .on_drag(ScrollbarDragging, |_, _, _, cx| cx.new(|_| Empty))
                .on_hover(|_, _, cx| {
                    cx.stop_propagation();
                })
@@ -302,16 +312,12 @@ impl MemoryView {
        .detach();
    }

-    fn handle_drag(&mut self, evt: &MouseMoveEvent) {
-        if !evt.dragging() {
-            return;
-        }
-        if !self.scroll_state.is_dragging()
-            && !self
-                .view_state
-                .selection
-                .as_ref()
-                .is_some_and(|selection| selection.is_dragging())
+    fn handle_memory_drag(&mut self, evt: &DragMoveEvent<Drag>) {
+        if !self
+            .view_state
+            .selection
+            .as_ref()
+            .is_some_and(|selection| selection.is_dragging())
        {
            return;
        }
@@ -319,25 +325,34 @@ impl MemoryView {
        debug_assert!(row_count > 1);
        let scroll_handle = self.scroll_state.scroll_handle();
        let viewport = scroll_handle.viewport();
-        let (top_area, bottom_area) = {
-            let size = size(viewport.size.width, viewport.size.height / 10.);
-            (
-                bounds(viewport.origin, size),
-                bounds(
-                    point(viewport.origin.x, viewport.origin.y + size.height * 2.),
-                    size,
-                ),
-            )
-        };

-        if bottom_area.contains(&evt.position) {
-            //ix == row_count - 1 {
+        if viewport.bottom() < evt.event.position.y {
            self.view_state.schedule_scroll_down();
-        } else if top_area.contains(&evt.position) {
+        } else if viewport.top() > evt.event.position.y {
            self.view_state.schedule_scroll_up();
        }
    }

+    fn handle_scroll_drag(&mut self, evt: &DragMoveEvent<ScrollbarDragging>) -> bool {
+        if !self.scroll_state.is_dragging() {
+            return false;
+        }
+        let row_count = self.view_state.row_count();
+        debug_assert!(row_count > 1);
+        let scroll_handle = self.scroll_state.scroll_handle();
+        let viewport = scroll_handle.viewport();
+
+        if viewport.bottom() < evt.event.position.y {
+            self.view_state.schedule_scroll_down();
+            true
+        } else if viewport.top() > evt.event.position.y {
+            self.view_state.schedule_scroll_up();
+            true
+        } else {
+            false
+        }
+    }
+
    fn editor_style(editor: &Entity<Editor>, cx: &Context<Self>) -> EditorStyle {
        let is_read_only = editor.read(cx).read_only(cx);
        let settings = ThemeSettings::get_global(cx);
@@ -583,16 +598,22 @@ impl MemoryView {
        else {
            return;
        };
+        let expr = format!("?${{{expr}}}");
        let reference = self.session.update(cx, |this, cx| {
            this.memory_reference_of_expr(selected_frame, expr, cx)
        });
        cx.spawn(async move |this, cx| {
-            if let Some(reference) = reference.await {
+            if let Some((reference, typ)) = reference.await {
                _ = this.update(cx, |this, cx| {
-                    let Ok(address) = parse_int::parse::<u64>(&reference) else {
-                        return;
+                    let sizeof_expr = if typ.as_ref().is_some_and(|t| {
+                        t.chars()
+                            .all(|c| c.is_whitespace() || c.is_alphabetic() || c == '*')
+                    }) {
+                        typ.as_deref()
+                    } else {
+                        None
                    };
-                    this.jump_to_address(address, cx);
+                    this.go_to_memory_reference(&reference, sizeof_expr, selected_frame, cx);
                });
            }
        })
@@ -763,7 +784,7 @@ fn render_single_memory_view_line(
                            this.when(selection.contains(base_address + cell_ix as u64), |this| {
                                let weak = weak.clone();

-                                this.bg(Color::Accent.color(cx)).when(
+                                this.bg(Color::Selected.color(cx).opacity(0.2)).when(
                                    !selection.is_dragging(),
                                    |this| {
                                        let selection = selection.drag().memory_range();
@@ -860,7 +881,7 @@ fn render_single_memory_view_line(
                        .px_0p5()
                        .when_some(view_state.selection.as_ref(), |this, selection| {
                            this.when(selection.contains(base_address + ix as u64), |this| {
-                                this.bg(Color::Accent.color(cx))
+                                this.bg(Color::Selected.color(cx).opacity(0.2))
                            })
                        })
                        .child(
@@ -944,8 +965,8 @@ impl Render for MemoryView {
            .child(
                v_flex()
                    .size_full()
-                    .on_mouse_move(cx.listener(|this, evt: &MouseMoveEvent, _, _| {
-                        this.handle_drag(evt);
+                    .on_drag_move(cx.listener(|this, evt, _, _| {
+                        this.handle_memory_drag(&evt);
                    }))
                    .child(self.render_memory(cx).size_full())
                    .children(self.open_context_menu.as_ref().map(|(menu, position, _)| {
--- a/crates/editor/src/actions.rs
+++ b/crates/editor/src/actions.rs
@@ -425,6 +425,8 @@ actions!(
        FoldRecursive,
        /// Folds the selected ranges.
        FoldSelectedRanges,
+        /// Toggles focus back to the last active buffer.
+        ToggleFocus,
        /// Toggles folding at the current position.
        ToggleFold,
        /// Toggles recursive folding at the current position.
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -356,6 +356,7 @@ pub fn init(cx: &mut App) {
            workspace.register_action(Editor::new_file_vertical);
            workspace.register_action(Editor::new_file_horizontal);
            workspace.register_action(Editor::cancel_language_server_work);
+            workspace.register_action(Editor::toggle_focus);
        },
    )
    .detach();
@@ -482,9 +483,7 @@ pub enum SelectMode {

 #[derive(Clone, PartialEq, Eq, Debug)]
 pub enum EditorMode {
-    SingleLine {
-        auto_width: bool,
-    },
+    SingleLine,
    AutoHeight {
        min_lines: usize,
        max_lines: Option<usize>,
@@ -1662,13 +1661,7 @@ impl Editor {
    pub fn single_line(window: &mut Window, cx: &mut Context<Self>) -> Self {
        let buffer = cx.new(|cx| Buffer::local("", cx));
        let buffer = cx.new(|cx| MultiBuffer::singleton(buffer, cx));
-        Self::new(
-            EditorMode::SingleLine { auto_width: false },
-            buffer,
-            None,
-            window,
-            cx,
-        )
+        Self::new(EditorMode::SingleLine, buffer, None, window, cx)
    }

    pub fn multi_line(window: &mut Window, cx: &mut Context<Self>) -> Self {
@@ -1677,18 +1670,6 @@ impl Editor {
        Self::new(EditorMode::full(), buffer, None, window, cx)
    }

-    pub fn auto_width(window: &mut Window, cx: &mut Context<Self>) -> Self {
-        let buffer = cx.new(|cx| Buffer::local("", cx));
-        let buffer = cx.new(|cx| MultiBuffer::singleton(buffer, cx));
-        Self::new(
-            EditorMode::SingleLine { auto_width: true },
-            buffer,
-            None,
-            window,
-            cx,
-        )
-    }
-
    pub fn auto_height(
        min_lines: usize,
        max_lines: usize,
@@ -16974,6 +16955,18 @@ impl Editor {
        cx.notify();
    }

+    pub fn toggle_focus(
+        workspace: &mut Workspace,
+        _: &actions::ToggleFocus,
+        window: &mut Window,
+        cx: &mut Context<Workspace>,
+    ) {
+        let Some(item) = workspace.recent_active_item_by_type::<Self>(cx) else {
+            return;
+        };
+        workspace.activate_item(&item, true, true, window, cx);
+    }
+
    pub fn toggle_fold(
        &mut self,
        _: &actions::ToggleFold,
@@ -20569,6 +20562,7 @@ impl Editor {
        if event.blurred != self.focus_handle {
            self.last_focused_descendant = Some(event.blurred);
        }
+        self.selection_drag_state = SelectionDragState::None;
        self.refresh_inlay_hints(InlayHintRefreshReason::ModifiersChanged(false), cx);
    }

--- a/crates/editor/src/element.rs
+++ b/crates/editor/src/element.rs
@@ -7787,46 +7787,13 @@ impl Element for EditorElement {
                editor.set_style(self.style.clone(), window, cx);

                let layout_id = match editor.mode {
-                    EditorMode::SingleLine { auto_width } => {
+                    EditorMode::SingleLine => {
                        let rem_size = window.rem_size();
-
                        let height = self.style.text.line_height_in_pixels(rem_size);
-                        if auto_width {
-                            let editor_handle = cx.entity().clone();
-                            let style = self.style.clone();
-                            window.request_measured_layout(
-                                Style::default(),
-                                move |_, _, window, cx| {
-                                    let editor_snapshot = editor_handle
-                                        .update(cx, |editor, cx| editor.snapshot(window, cx));
-                                    let line = Self::layout_lines(
-                                        DisplayRow(0)..DisplayRow(1),
-                                        &editor_snapshot,
-                                        &style,
-                                        px(f32::MAX),
-                                        |_| false, // Single lines never soft wrap
-                                        window,
-                                        cx,
-                                    )
-                                    .pop()
-                                    .unwrap();
-
-                                    let font_id =
-                                        window.text_system().resolve_font(&style.text.font());
-                                    let font_size =
-                                        style.text.font_size.to_pixels(window.rem_size());
-                                    let em_width =
-                                        window.text_system().em_width(font_id, font_size).unwrap();
-
-                                    size(line.width + em_width, height)
-                                },
-                            )
-                        } else {
-                            let mut style = Style::default();
-                            style.size.height = height.into();
-                            style.size.width = relative(1.).into();
-                            window.request_layout(style, None, cx)
-                        }
+                        let mut style = Style::default();
+                        style.size.height = height.into();
+                        style.size.width = relative(1.).into();
+                        window.request_layout(style, None, cx)
                    }
                    EditorMode::AutoHeight {
                        min_lines,
@@ -10390,7 +10357,7 @@ mod tests {
        });

        for editor_mode_without_invisibles in [
-            EditorMode::SingleLine { auto_width: false },
+            EditorMode::SingleLine,
            EditorMode::AutoHeight {
                min_lines: 1,
                max_lines: Some(100),
--- a/crates/eval/src/example.rs
+++ b/crates/eval/src/example.rs
@@ -221,9 +221,6 @@ impl ExampleContext {
                ThreadEvent::ShowError(thread_error) => {
                    tx.try_send(Err(anyhow!(thread_error.clone()))).ok();
                }
-                ThreadEvent::RetriesFailed { .. } => {
-                    // Ignore retries failed events
-                }
                ThreadEvent::Stopped(reason) => match reason {
                    Ok(StopReason::EndTurn) => {
                        tx.close_channel();
--- a/crates/extensions_ui/src/extensions_ui.rs
+++ b/crates/extensions_ui/src/extensions_ui.rs
@@ -6,6 +6,7 @@ use std::sync::OnceLock;
 use std::time::Duration;
 use std::{ops::Range, sync::Arc};

+use anyhow::Context as _;
 use client::{ExtensionMetadata, ExtensionProvides};
 use collections::{BTreeMap, BTreeSet};
 use editor::{Editor, EditorElement, EditorStyle};
@@ -23,7 +24,7 @@ use settings::Settings;
 use strum::IntoEnumIterator as _;
 use theme::ThemeSettings;
 use ui::{
-    CheckboxWithLabel, ContextMenu, PopoverMenu, ScrollableHandle, Scrollbar, ScrollbarState,
+    CheckboxWithLabel, Chip, ContextMenu, PopoverMenu, ScrollableHandle, Scrollbar, ScrollbarState,
    ToggleButton, Tooltip, prelude::*,
 };
 use vim_mode_setting::VimModeSetting;
@@ -80,16 +81,24 @@ pub fn init(cx: &mut App) {
                        .find_map(|item| item.downcast::<ExtensionsPage>());

                    if let Some(existing) = existing {
-                        if provides_filter.is_some() {
-                            existing.update(cx, |extensions_page, cx| {
+                        existing.update(cx, |extensions_page, cx| {
+                            if provides_filter.is_some() {
                                extensions_page.change_provides_filter(provides_filter, cx);
-                            });
-                        }
+                            }
+                            if let Some(id) = action.id.as_ref() {
+                                extensions_page.focus_extension(id, window, cx);
+                            }
+                        });

                        workspace.activate_item(&existing, true, true, window, cx);
                    } else {
-                        let extensions_page =
-                            ExtensionsPage::new(workspace, provides_filter, window, cx);
+                        let extensions_page = ExtensionsPage::new(
+                            workspace,
+                            provides_filter,
+                            action.id.as_deref(),
+                            window,
+                            cx,
+                        );
                        workspace.add_item_to_active_pane(
                            Box::new(extensions_page),
                            None,
@@ -287,6 +296,7 @@ impl ExtensionsPage {
    pub fn new(
        workspace: &Workspace,
        provides_filter: Option<ExtensionProvides>,
+        focus_extension_id: Option<&str>,
        window: &mut Window,
        cx: &mut Context<Workspace>,
    ) -> Entity<Self> {
@@ -317,6 +327,9 @@ impl ExtensionsPage {
            let query_editor = cx.new(|cx| {
                let mut input = Editor::single_line(window, cx);
                input.set_placeholder_text("Search extensions...", cx);
+                if let Some(id) = focus_extension_id {
+                    input.set_text(format!("id:{id}"), window, cx);
+                }
                input
            });
            cx.subscribe(&query_editor, Self::on_query_change).detach();
@@ -340,7 +353,7 @@ impl ExtensionsPage {
                scrollbar_state: ScrollbarState::new(scroll_handle),
            };
            this.fetch_extensions(
-                None,
+                this.search_query(cx),
                Some(BTreeSet::from_iter(this.provides_filter)),
                None,
                cx,
@@ -464,9 +477,23 @@ impl ExtensionsPage {
            .cloned()
            .collect::<Vec<_>>();

-        let remote_extensions = extension_store.update(cx, |store, cx| {
-            store.fetch_extensions(search.as_deref(), provides_filter.as_ref(), cx)
-        });
+        let remote_extensions =
+            if let Some(id) = search.as_ref().and_then(|s| s.strip_prefix("id:")) {
+                let versions =
+                    extension_store.update(cx, |store, cx| store.fetch_extension_versions(id, cx));
+                cx.foreground_executor().spawn(async move {
+                    let versions = versions.await?;
+                    let latest = versions
+                        .into_iter()
+                        .max_by_key(|v| v.published_at)
+                        .context("no extension found")?;
+                    Ok(vec![latest])
+                })
+            } else {
+                extension_store.update(cx, |store, cx| {
+                    store.fetch_extensions(search.as_deref(), provides_filter.as_ref(), cx)
+                })
+            };

        cx.spawn(async move |this, cx| {
            let dev_extensions = if let Some(search) = search {
@@ -732,20 +759,7 @@ impl ExtensionsPage {
                                                    _ => {}
                                                }

-                                                Some(
-                                                    div()
-                                                        .px_1()
-                                                        .border_1()
-                                                        .rounded_sm()
-                                                        .border_color(cx.theme().colors().border)
-                                                        .bg(cx.theme().colors().element_background)
-                                                        .child(
-                                                            Label::new(extension_provides_label(
-                                                                *provides,
-                                                            ))
-                                                            .size(LabelSize::XSmall),
-                                                        ),
-                                                )
+                                                Some(Chip::new(extension_provides_label(*provides)))
                                            })
                                            .collect::<Vec<_>>(),
                                    ),
@@ -1165,6 +1179,13 @@ impl ExtensionsPage {
        self.refresh_feature_upsells(cx);
    }

+    pub fn focus_extension(&mut self, id: &str, window: &mut Window, cx: &mut Context<Self>) {
+        self.query_editor.update(cx, |editor, cx| {
+            editor.set_text(format!("id:{id}"), window, cx)
+        });
+        self.refresh_search(cx);
+    }
+
    pub fn change_provides_filter(
        &mut self,
        provides_filter: Option<ExtensionProvides>,
--- a/crates/gpui/build.rs
+++ b/crates/gpui/build.rs
@@ -126,7 +126,7 @@ mod macos {
            "ContentMask".into(),
            "Uniforms".into(),
            "AtlasTile".into(),
-            "PathInputIndex".into(),
+            "PathRasterizationInputIndex".into(),
            "PathVertex_ScaledPixels".into(),
            "ShadowInputIndex".into(),
            "Shadow".into(),
--- a/crates/gpui/examples/painting.rs
+++ b/crates/gpui/examples/painting.rs
@@ -1,13 +1,9 @@
 use gpui::{
    Application, Background, Bounds, ColorSpace, Context, MouseDownEvent, Path, PathBuilder,
-    PathStyle, Pixels, Point, Render, SharedString, StrokeOptions, Window, WindowBounds,
-    WindowOptions, canvas, div, linear_color_stop, linear_gradient, point, prelude::*, px, rgb,
-    size,
+    PathStyle, Pixels, Point, Render, SharedString, StrokeOptions, Window, WindowOptions, canvas,
+    div, linear_color_stop, linear_gradient, point, prelude::*, px, rgb, size,
 };

-const DEFAULT_WINDOW_WIDTH: Pixels = px(1024.0);
-const DEFAULT_WINDOW_HEIGHT: Pixels = px(768.0);
-
 struct PaintingViewer {
    default_lines: Vec<(Path<Pixels>, Background)>,
    lines: Vec<Vec<Point<Pixels>>>,
@@ -151,6 +147,8 @@ impl PaintingViewer {
                px(320.0 + (i as f32 * 10.0).sin() * 40.0),
            ));
        }
+        let path = builder.build().unwrap();
+        lines.push((path, gpui::green().into()));

        Self {
            default_lines: lines.clone(),
@@ -185,13 +183,9 @@ fn button(
 }

 impl Render for PaintingViewer {
-    fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
-        window.request_animation_frame();
-
+    fn render(&mut self, _: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
        let default_lines = self.default_lines.clone();
        let lines = self.lines.clone();
-        let window_size = window.bounds().size;
-        let scale = window_size.width / DEFAULT_WINDOW_WIDTH;
        let dashed = self.dashed;

        div()
@@ -228,7 +222,7 @@ impl Render for PaintingViewer {
                            move |_, _, _| {},
                            move |_, _, window, _| {
                                for (path, color) in default_lines {
-                                    window.paint_path(path.clone().scale(scale), color);
+                                    window.paint_path(path, color);
                                }

                                for points in lines {
@@ -304,11 +298,6 @@ fn main() {
        cx.open_window(
            WindowOptions {
                focus: true,
-                window_bounds: Some(WindowBounds::Windowed(Bounds::centered(
-                    None,
-                    size(DEFAULT_WINDOW_WIDTH, DEFAULT_WINDOW_HEIGHT),
-                    cx,
-                ))),
                ..Default::default()
            },
            |window, cx| cx.new(|cx| PaintingViewer::new(window, cx)),
--- a/crates/gpui/src/path_builder.rs
+++ b/crates/gpui/src/path_builder.rs
@@ -336,7 +336,10 @@ impl PathBuilder {
            let v1 = buf.vertices[i1];
            let v2 = buf.vertices[i2];

-            path.push_triangle((v0.into(), v1.into(), v2.into()));
+            path.push_triangle(
+                (v0.into(), v1.into(), v2.into()),
+                (point(0., 1.), point(0., 1.), point(0., 1.)),
+            );
        }

        path
--- a/crates/gpui/src/platform.rs
+++ b/crates/gpui/src/platform.rs
@@ -794,6 +794,7 @@ pub(crate) struct AtlasTextureId {
 pub(crate) enum AtlasTextureKind {
    Monochrome = 0,
    Polychrome = 1,
+    Path = 2,
 }

 #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
--- a/crates/gpui/src/platform/blade/blade_atlas.rs
+++ b/crates/gpui/src/platform/blade/blade_atlas.rs
@@ -10,6 +10,8 @@ use etagere::BucketedAtlasAllocator;
 use parking_lot::Mutex;
 use std::{borrow::Cow, ops, sync::Arc};

+pub(crate) const PATH_TEXTURE_FORMAT: gpu::TextureFormat = gpu::TextureFormat::R16Float;
+
 pub(crate) struct BladeAtlas(Mutex<BladeAtlasState>);

 struct PendingUpload {
@@ -25,6 +27,7 @@ struct BladeAtlasState {
    tiles_by_key: FxHashMap<AtlasKey, AtlasTile>,
    initializations: Vec<AtlasTextureId>,
    uploads: Vec<PendingUpload>,
+    path_sample_count: u32,
 }

 #[cfg(gles)]
@@ -38,13 +41,13 @@ impl BladeAtlasState {
 }

 pub struct BladeTextureInfo {
-    #[allow(dead_code)]
    pub size: gpu::Extent,
    pub raw_view: gpu::TextureView,
+    pub msaa_view: Option<gpu::TextureView>,
 }

 impl BladeAtlas {
-    pub(crate) fn new(gpu: &Arc<gpu::Context>) -> Self {
+    pub(crate) fn new(gpu: &Arc<gpu::Context>, path_sample_count: u32) -> Self {
        BladeAtlas(Mutex::new(BladeAtlasState {
            gpu: Arc::clone(gpu),
            upload_belt: BufferBelt::new(BufferBeltDescriptor {
@@ -56,6 +59,7 @@ impl BladeAtlas {
            tiles_by_key: Default::default(),
            initializations: Vec::new(),
            uploads: Vec::new(),
+            path_sample_count,
        }))
    }

@@ -63,7 +67,6 @@ impl BladeAtlas {
        self.0.lock().destroy();
    }

-    #[allow(dead_code)]
    pub(crate) fn clear_textures(&self, texture_kind: AtlasTextureKind) {
        let mut lock = self.0.lock();
        let textures = &mut lock.storage[texture_kind];
@@ -72,6 +75,19 @@ impl BladeAtlas {
        }
    }

+    /// Allocate a rectangle and make it available for rendering immediately (without waiting for `before_frame`)
+    pub fn allocate_for_rendering(
+        &self,
+        size: Size<DevicePixels>,
+        texture_kind: AtlasTextureKind,
+        gpu_encoder: &mut gpu::CommandEncoder,
+    ) -> AtlasTile {
+        let mut lock = self.0.lock();
+        let tile = lock.allocate(size, texture_kind);
+        lock.flush_initializations(gpu_encoder);
+        tile
+    }
+
    pub fn before_frame(&self, gpu_encoder: &mut gpu::CommandEncoder) {
        let mut lock = self.0.lock();
        lock.flush(gpu_encoder);
@@ -93,6 +109,7 @@ impl BladeAtlas {
                depth: 1,
            },
            raw_view: texture.raw_view,
+            msaa_view: texture.msaa_view,
        }
    }
 }
@@ -183,8 +200,48 @@ impl BladeAtlasState {
                format = gpu::TextureFormat::Bgra8UnormSrgb;
                usage = gpu::TextureUsage::COPY | gpu::TextureUsage::RESOURCE;
            }
+            AtlasTextureKind::Path => {
+                format = PATH_TEXTURE_FORMAT;
+                usage = gpu::TextureUsage::COPY
+                    | gpu::TextureUsage::RESOURCE
+                    | gpu::TextureUsage::TARGET;
+            }
        }

+        // We currently only enable MSAA for path textures.
+        let (msaa, msaa_view) = if self.path_sample_count > 1 && kind == AtlasTextureKind::Path {
+            let msaa = self.gpu.create_texture(gpu::TextureDesc {
+                name: "msaa path texture",
+                format,
+                size: gpu::Extent {
+                    width: size.width.into(),
+                    height: size.height.into(),
+                    depth: 1,
+                },
+                array_layer_count: 1,
+                mip_level_count: 1,
+                sample_count: self.path_sample_count,
+                dimension: gpu::TextureDimension::D2,
+                usage: gpu::TextureUsage::TARGET,
+                external: None,
+            });
+
+            (
+                Some(msaa),
+                Some(self.gpu.create_texture_view(
+                    msaa,
+                    gpu::TextureViewDesc {
+                        name: "msaa texture view",
+                        format,
+                        dimension: gpu::ViewDimension::D2,
+                        subresources: &Default::default(),
+                    },
+                )),
+            )
+        } else {
+            (None, None)
+        };
+
        let raw = self.gpu.create_texture(gpu::TextureDesc {
            name: "atlas",
            format,
@@ -222,6 +279,8 @@ impl BladeAtlasState {
            format,
            raw,
            raw_view,
+            msaa,
+            msaa_view,
            live_atlas_keys: 0,
        };

@@ -281,6 +340,7 @@ impl BladeAtlasState {
 struct BladeAtlasStorage {
    monochrome_textures: AtlasTextureList<BladeAtlasTexture>,
    polychrome_textures: AtlasTextureList<BladeAtlasTexture>,
+    path_textures: AtlasTextureList<BladeAtlasTexture>,
 }

 impl ops::Index<AtlasTextureKind> for BladeAtlasStorage {
@@ -289,6 +349,7 @@ impl ops::Index<AtlasTextureKind> for BladeAtlasStorage {
        match kind {
            crate::AtlasTextureKind::Monochrome => &self.monochrome_textures,
            crate::AtlasTextureKind::Polychrome => &self.polychrome_textures,
+            crate::AtlasTextureKind::Path => &self.path_textures,
        }
    }
 }
@@ -298,6 +359,7 @@ impl ops::IndexMut<AtlasTextureKind> for BladeAtlasStorage {
        match kind {
            crate::AtlasTextureKind::Monochrome => &mut self.monochrome_textures,
            crate::AtlasTextureKind::Polychrome => &mut self.polychrome_textures,
+            crate::AtlasTextureKind::Path => &mut self.path_textures,
        }
    }
 }
@@ -308,6 +370,7 @@ impl ops::Index<AtlasTextureId> for BladeAtlasStorage {
        let textures = match id.kind {
            crate::AtlasTextureKind::Monochrome => &self.monochrome_textures,
            crate::AtlasTextureKind::Polychrome => &self.polychrome_textures,
+            crate::AtlasTextureKind::Path => &self.path_textures,
        };
        textures[id.index as usize].as_ref().unwrap()
    }
@@ -321,6 +384,9 @@ impl BladeAtlasStorage {
        for mut texture in self.polychrome_textures.drain().flatten() {
            texture.destroy(gpu);
        }
+        for mut texture in self.path_textures.drain().flatten() {
+            texture.destroy(gpu);
+        }
    }
 }

@@ -329,6 +395,8 @@ struct BladeAtlasTexture {
    allocator: BucketedAtlasAllocator,
    raw: gpu::Texture,
    raw_view: gpu::TextureView,
+    msaa: Option<gpu::Texture>,
+    msaa_view: Option<gpu::TextureView>,
    format: gpu::TextureFormat,
    live_atlas_keys: u32,
 }
@@ -356,6 +424,12 @@ impl BladeAtlasTexture {
    fn destroy(&mut self, gpu: &gpu::Context) {
        gpu.destroy_texture(self.raw);
        gpu.destroy_texture_view(self.raw_view);
+        if let Some(msaa) = self.msaa {
+            gpu.destroy_texture(msaa);
+        }
+        if let Some(msaa_view) = self.msaa_view {
+            gpu.destroy_texture_view(msaa_view);
+        }
    }

    fn bytes_per_pixel(&self) -> u8 {
--- a/crates/gpui/src/platform/blade/blade_renderer.rs
+++ b/crates/gpui/src/platform/blade/blade_renderer.rs
@@ -1,19 +1,24 @@
 // Doing `if let` gives you nice scoping with passes/encoders
 #![allow(irrefutable_let_patterns)]

-use super::{BladeAtlas, BladeContext};
+use super::{BladeAtlas, BladeContext, PATH_TEXTURE_FORMAT};
 use crate::{
-    Background, Bounds, ContentMask, DevicePixels, GpuSpecs, MonochromeSprite, PathVertex,
-    PolychromeSprite, PrimitiveBatch, Quad, ScaledPixels, Scene, Shadow, Size, Underline,
+    AtlasTextureKind, AtlasTile, Background, Bounds, ContentMask, DevicePixels, GpuSpecs,
+    MonochromeSprite, Path, PathId, PathVertex, PolychromeSprite, PrimitiveBatch, Quad,
+    ScaledPixels, Scene, Shadow, Size, Underline,
 };
-use blade_graphics::{self as gpu};
+use blade_graphics as gpu;
 use blade_util::{BufferBelt, BufferBeltDescriptor};
 use bytemuck::{Pod, Zeroable};
+use collections::HashMap;
 #[cfg(target_os = "macos")]
 use media::core_video::CVMetalTextureCache;
 use std::{mem, sync::Arc};

 const MAX_FRAME_TIME_MS: u32 = 10000;
+// Use 4x MSAA, all devices support it.
+// https://developer.apple.com/documentation/metal/mtldevice/1433355-supportstexturesamplecount
+const DEFAULT_PATH_SAMPLE_COUNT: u32 = 4;

 #[repr(C)]
 #[derive(Clone, Copy, Pod, Zeroable)]
@@ -61,9 +66,16 @@ struct ShaderShadowsData {
 }

 #[derive(blade_macros::ShaderData)]
-struct ShaderPathsData {
+struct ShaderPathRasterizationData {
    globals: GlobalParams,
    b_path_vertices: gpu::BufferPiece,
+}
+
+#[derive(blade_macros::ShaderData)]
+struct ShaderPathsData {
+    globals: GlobalParams,
+    t_sprite: gpu::TextureView,
+    s_sprite: gpu::Sampler,
    b_path_sprites: gpu::BufferPiece,
 }

@@ -103,27 +115,13 @@ struct ShaderSurfacesData {
 struct PathSprite {
    bounds: Bounds<ScaledPixels>,
    color: Background,
-}
-
-/// Argument buffer layout for `draw_indirect` commands.
-#[repr(C)]
-#[derive(Copy, Clone, Debug, Default, Pod, Zeroable)]
-pub struct DrawIndirectArgs {
-    /// The number of vertices to draw.
-    pub vertex_count: u32,
-    /// The number of instances to draw.
-    pub instance_count: u32,
-    /// The Index of the first vertex to draw.
-    pub first_vertex: u32,
-    /// The instance ID of the first instance to draw.
-    ///
-    /// Has to be 0, unless [`Features::INDIRECT_FIRST_INSTANCE`](crate::Features::INDIRECT_FIRST_INSTANCE) is enabled.
-    pub first_instance: u32,
+    tile: AtlasTile,
 }

 struct BladePipelines {
    quads: gpu::RenderPipeline,
    shadows: gpu::RenderPipeline,
+    path_rasterization: gpu::RenderPipeline,
    paths: gpu::RenderPipeline,
    underlines: gpu::RenderPipeline,
    mono_sprites: gpu::RenderPipeline,
@@ -132,7 +130,7 @@ struct BladePipelines {
 }

 impl BladePipelines {
-    fn new(gpu: &gpu::Context, surface_info: gpu::SurfaceInfo, sample_count: u32) -> Self {
+    fn new(gpu: &gpu::Context, surface_info: gpu::SurfaceInfo, path_sample_count: u32) -> Self {
        use gpu::ShaderData as _;

        log::info!(
@@ -180,10 +178,7 @@ impl BladePipelines {
                depth_stencil: None,
                fragment: Some(shader.at("fs_quad")),
                color_targets,
-                multisample_state: gpu::MultisampleState {
-                    sample_count,
-                    ..Default::default()
-                },
+                multisample_state: gpu::MultisampleState::default(),
            }),
            shadows: gpu.create_render_pipeline(gpu::RenderPipelineDesc {
                name: "shadows",
@@ -197,8 +192,26 @@ impl BladePipelines {
                depth_stencil: None,
                fragment: Some(shader.at("fs_shadow")),
                color_targets,
+                multisample_state: gpu::MultisampleState::default(),
+            }),
+            path_rasterization: gpu.create_render_pipeline(gpu::RenderPipelineDesc {
+                name: "path_rasterization",
+                data_layouts: &[&ShaderPathRasterizationData::layout()],
+                vertex: shader.at("vs_path_rasterization"),
+                vertex_fetches: &[],
+                primitive: gpu::PrimitiveState {
+                    topology: gpu::PrimitiveTopology::TriangleList,
+                    ..Default::default()
+                },
+                depth_stencil: None,
+                fragment: Some(shader.at("fs_path_rasterization")),
+                color_targets: &[gpu::ColorTargetState {
+                    format: PATH_TEXTURE_FORMAT,
+                    blend: Some(gpu::BlendState::ADDITIVE),
+                    write_mask: gpu::ColorWrites::default(),
+                }],
                multisample_state: gpu::MultisampleState {
-                    sample_count,
+                    sample_count: path_sample_count,
                    ..Default::default()
                },
            }),
@@ -208,16 +221,13 @@ impl BladePipelines {
                vertex: shader.at("vs_path"),
                vertex_fetches: &[],
                primitive: gpu::PrimitiveState {
-                    topology: gpu::PrimitiveTopology::TriangleList,
+                    topology: gpu::PrimitiveTopology::TriangleStrip,
                    ..Default::default()
                },
                depth_stencil: None,
                fragment: Some(shader.at("fs_path")),
                color_targets,
-                multisample_state: gpu::MultisampleState {
-                    sample_count,
-                    ..Default::default()
-                },
+                multisample_state: gpu::MultisampleState::default(),
            }),
            underlines: gpu.create_render_pipeline(gpu::RenderPipelineDesc {
                name: "underlines",
@@ -231,10 +241,7 @@ impl BladePipelines {
                depth_stencil: None,
                fragment: Some(shader.at("fs_underline")),
                color_targets,
-                multisample_state: gpu::MultisampleState {
-                    sample_count,
-                    ..Default::default()
-                },
+                multisample_state: gpu::MultisampleState::default(),
            }),
            mono_sprites: gpu.create_render_pipeline(gpu::RenderPipelineDesc {
                name: "mono-sprites",
@@ -248,10 +255,7 @@ impl BladePipelines {
                depth_stencil: None,
                fragment: Some(shader.at("fs_mono_sprite")),
                color_targets,
-                multisample_state: gpu::MultisampleState {
-                    sample_count,
-                    ..Default::default()
-                },
+                multisample_state: gpu::MultisampleState::default(),
            }),
            poly_sprites: gpu.create_render_pipeline(gpu::RenderPipelineDesc {
                name: "poly-sprites",
@@ -265,10 +269,7 @@ impl BladePipelines {
                depth_stencil: None,
                fragment: Some(shader.at("fs_poly_sprite")),
                color_targets,
-                multisample_state: gpu::MultisampleState {
-                    sample_count,
-                    ..Default::default()
-                },
+                multisample_state: gpu::MultisampleState::default(),
            }),
            surfaces: gpu.create_render_pipeline(gpu::RenderPipelineDesc {
                name: "surfaces",
@@ -282,10 +283,7 @@ impl BladePipelines {
                depth_stencil: None,
                fragment: Some(shader.at("fs_surface")),
                color_targets,
-                multisample_state: gpu::MultisampleState {
-                    sample_count,
-                    ..Default::default()
-                },
+                multisample_state: gpu::MultisampleState::default(),
            }),
        }
    }
@@ -293,6 +291,7 @@ impl BladePipelines {
    fn destroy(&mut self, gpu: &gpu::Context) {
        gpu.destroy_render_pipeline(&mut self.quads);
        gpu.destroy_render_pipeline(&mut self.shadows);
+        gpu.destroy_render_pipeline(&mut self.path_rasterization);
        gpu.destroy_render_pipeline(&mut self.paths);
        gpu.destroy_render_pipeline(&mut self.underlines);
        gpu.destroy_render_pipeline(&mut self.mono_sprites);
@@ -318,13 +317,12 @@ pub struct BladeRenderer {
    last_sync_point: Option<gpu::SyncPoint>,
    pipelines: BladePipelines,
    instance_belt: BufferBelt,
+    path_tiles: HashMap<PathId, AtlasTile>,
    atlas: Arc<BladeAtlas>,
    atlas_sampler: gpu::Sampler,
    #[cfg(target_os = "macos")]
    core_video_texture_cache: CVMetalTextureCache,
-    sample_count: u32,
-    texture_msaa: Option<gpu::Texture>,
-    texture_view_msaa: Option<gpu::TextureView>,
+    path_sample_count: u32,
 }

 impl BladeRenderer {
@@ -333,18 +331,6 @@ impl BladeRenderer {
        window: &I,
        config: BladeSurfaceConfig,
    ) -> anyhow::Result<Self> {
-        // workaround for https://github.com/zed-industries/zed/issues/26143
-        let sample_count = std::env::var("ZED_SAMPLE_COUNT")
-            .ok()
-            .or_else(|| std::env::var("ZED_PATH_SAMPLE_COUNT").ok())
-            .and_then(|v| v.parse().ok())
-            .or_else(|| {
-                [4, 2, 1]
-                    .into_iter()
-                    .find(|count| context.gpu.supports_texture_sample_count(*count))
-            })
-            .unwrap_or(1);
-
        let surface_config = gpu::SurfaceConfig {
            size: config.size,
            usage: gpu::TextureUsage::TARGET,
@@ -358,27 +344,22 @@ impl BladeRenderer {
            .create_surface_configured(window, surface_config)
            .map_err(|err| anyhow::anyhow!("Failed to create surface: {err:?}"))?;

-        let (texture_msaa, texture_view_msaa) = create_msaa_texture_if_needed(
-            &context.gpu,
-            surface.info().format,
-            config.size.width,
-            config.size.height,
-            sample_count,
-        )
-        .unzip();
-
        let command_encoder = context.gpu.create_command_encoder(gpu::CommandEncoderDesc {
            name: "main",
            buffer_count: 2,
        });
-
-        let pipelines = BladePipelines::new(&context.gpu, surface.info(), sample_count);
+        // workaround for https://github.com/zed-industries/zed/issues/26143
+        let path_sample_count = std::env::var("ZED_PATH_SAMPLE_COUNT")
+            .ok()
+            .and_then(|v| v.parse().ok())
+            .unwrap_or(DEFAULT_PATH_SAMPLE_COUNT);
+        let pipelines = BladePipelines::new(&context.gpu, surface.info(), path_sample_count);
        let instance_belt = BufferBelt::new(BufferBeltDescriptor {
            memory: gpu::Memory::Shared,
            min_chunk_size: 0x1000,
            alignment: 0x40, // Vulkan `minStorageBufferOffsetAlignment` on Intel Xe
        });
-        let atlas = Arc::new(BladeAtlas::new(&context.gpu));
+        let atlas = Arc::new(BladeAtlas::new(&context.gpu, path_sample_count));
        let atlas_sampler = context.gpu.create_sampler(gpu::SamplerDesc {
            name: "atlas",
            mag_filter: gpu::FilterMode::Linear,
@@ -402,13 +383,12 @@ impl BladeRenderer {
            last_sync_point: None,
            pipelines,
            instance_belt,
+            path_tiles: HashMap::default(),
            atlas,
            atlas_sampler,
            #[cfg(target_os = "macos")]
            core_video_texture_cache,
-            sample_count,
-            texture_msaa,
-            texture_view_msaa,
+            path_sample_count,
        })
    }

@@ -461,24 +441,6 @@ impl BladeRenderer {
            self.surface_config.size = gpu_size;
            self.gpu
                .reconfigure_surface(&mut self.surface, self.surface_config);
-
-            if let Some(texture_msaa) = self.texture_msaa {
-                self.gpu.destroy_texture(texture_msaa);
-            }
-            if let Some(texture_view_msaa) = self.texture_view_msaa {
-                self.gpu.destroy_texture_view(texture_view_msaa);
-            }
-
-            let (texture_msaa, texture_view_msaa) = create_msaa_texture_if_needed(
-                &self.gpu,
-                self.surface.info().format,
-                gpu_size.width,
-                gpu_size.height,
-                self.sample_count,
-            )
-            .unzip();
-            self.texture_msaa = texture_msaa;
-            self.texture_view_msaa = texture_view_msaa;
        }
    }

@@ -489,7 +451,8 @@ impl BladeRenderer {
            self.gpu
                .reconfigure_surface(&mut self.surface, self.surface_config);
            self.pipelines.destroy(&self.gpu);
-            self.pipelines = BladePipelines::new(&self.gpu, self.surface.info(), self.sample_count);
+            self.pipelines =
+                BladePipelines::new(&self.gpu, self.surface.info(), self.path_sample_count);
        }
    }

@@ -527,6 +490,80 @@ impl BladeRenderer {
        objc2::rc::Retained::as_ptr(&self.surface.metal_layer()) as *mut _
    }

+    #[profiling::function]
+    fn rasterize_paths(&mut self, paths: &[Path<ScaledPixels>]) {
+        self.path_tiles.clear();
+        let mut vertices_by_texture_id = HashMap::default();
+
+        for path in paths {
+            let clipped_bounds = path
+                .bounds
+                .intersect(&path.content_mask.bounds)
+                .map_origin(|origin| origin.floor())
+                .map_size(|size| size.ceil());
+            let tile = self.atlas.allocate_for_rendering(
+                clipped_bounds.size.map(Into::into),
+                AtlasTextureKind::Path,
+                &mut self.command_encoder,
+            );
+            vertices_by_texture_id
+                .entry(tile.texture_id)
+                .or_insert(Vec::new())
+                .extend(path.vertices.iter().map(|vertex| PathVertex {
+                    xy_position: vertex.xy_position - clipped_bounds.origin
+                        + tile.bounds.origin.map(Into::into),
+                    st_position: vertex.st_position,
+                    content_mask: ContentMask {
+                        bounds: tile.bounds.map(Into::into),
+                    },
+                }));
+            self.path_tiles.insert(path.id, tile);
+        }
+
+        for (texture_id, vertices) in vertices_by_texture_id {
+            let tex_info = self.atlas.get_texture_info(texture_id);
+            let globals = GlobalParams {
+                viewport_size: [tex_info.size.width as f32, tex_info.size.height as f32],
+                premultiplied_alpha: 0,
+                pad: 0,
+            };
+
+            let vertex_buf = unsafe { self.instance_belt.alloc_typed(&vertices, &self.gpu) };
+            let frame_view = tex_info.raw_view;
+            let color_target = if let Some(msaa_view) = tex_info.msaa_view {
+                gpu::RenderTarget {
+                    view: msaa_view,
+                    init_op: gpu::InitOp::Clear(gpu::TextureColor::OpaqueBlack),
+                    finish_op: gpu::FinishOp::ResolveTo(frame_view),
+                }
+            } else {
+                gpu::RenderTarget {
+                    view: frame_view,
+                    init_op: gpu::InitOp::Clear(gpu::TextureColor::OpaqueBlack),
+                    finish_op: gpu::FinishOp::Store,
+                }
+            };
+
+            if let mut pass = self.command_encoder.render(
+                "paths",
+                gpu::RenderTargetSet {
+                    colors: &[color_target],
+                    depth_stencil: None,
+                },
+            ) {
+                let mut encoder = pass.with(&self.pipelines.path_rasterization);
+                encoder.bind(
+                    0,
+                    &ShaderPathRasterizationData {
+                        globals,
+                        b_path_vertices: vertex_buf,
+                    },
+                );
+                encoder.draw(0, vertices.len() as u32, 0, 1);
+            }
+        }
+    }
+
    pub fn destroy(&mut self) {
        self.wait_for_gpu();
        self.atlas.destroy();
@@ -535,26 +572,17 @@ impl BladeRenderer {
        self.gpu.destroy_command_encoder(&mut self.command_encoder);
        self.pipelines.destroy(&self.gpu);
        self.gpu.destroy_surface(&mut self.surface);
-        if let Some(texture_msaa) = self.texture_msaa {
-            self.gpu.destroy_texture(texture_msaa);
-        }
-        if let Some(texture_view_msaa) = self.texture_view_msaa {
-            self.gpu.destroy_texture_view(texture_view_msaa);
-        }
    }

    pub fn draw(&mut self, scene: &Scene) {
        self.command_encoder.start();
        self.atlas.before_frame(&mut self.command_encoder);
+        self.rasterize_paths(scene.paths());

        let frame = {
            profiling::scope!("acquire frame");
            self.surface.acquire_frame()
        };
-        let frame_view = frame.texture_view();
-        if let Some(texture_msaa) = self.texture_msaa {
-            self.command_encoder.init_texture(texture_msaa);
-        }
        self.command_encoder.init_texture(frame.texture());

        let globals = GlobalParams {
@@ -569,25 +597,14 @@ impl BladeRenderer {
            pad: 0,
        };

-        let target = if let Some(texture_view_msaa) = self.texture_view_msaa {
-            gpu::RenderTarget {
-                view: texture_view_msaa,
-                init_op: gpu::InitOp::Clear(gpu::TextureColor::TransparentBlack),
-                finish_op: gpu::FinishOp::ResolveTo(frame_view),
-            }
-        } else {
-            gpu::RenderTarget {
-                view: frame_view,
-                init_op: gpu::InitOp::Clear(gpu::TextureColor::TransparentBlack),
-                finish_op: gpu::FinishOp::Store,
-            }
-        };
-
-        // draw to the target texture
        if let mut pass = self.command_encoder.render(
            "main",
            gpu::RenderTargetSet {
-                colors: &[target],
+                colors: &[gpu::RenderTarget {
+                    view: frame.texture_view(),
+                    init_op: gpu::InitOp::Clear(gpu::TextureColor::TransparentBlack),
+                    finish_op: gpu::FinishOp::Store,
+                }],
                depth_stencil: None,
            },
        ) {
@@ -622,55 +639,32 @@ impl BladeRenderer {
                    }
                    PrimitiveBatch::Paths(paths) => {
                        let mut encoder = pass.with(&self.pipelines.paths);
-
-                        let mut vertices = Vec::new();
-                        let mut sprites = Vec::with_capacity(paths.len());
-                        let mut draw_indirect_commands = Vec::with_capacity(paths.len());
-                        let mut first_vertex = 0;
-
-                        for (i, path) in paths.iter().enumerate() {
-                            draw_indirect_commands.push(DrawIndirectArgs {
-                                vertex_count: path.vertices.len() as u32,
-                                instance_count: 1,
-                                first_vertex,
-                                first_instance: i as u32,
-                            });
-                            first_vertex += path.vertices.len() as u32;
-
-                            vertices.extend(path.vertices.iter().map(|v| PathVertex {
-                                xy_position: v.xy_position,
-                                content_mask: ContentMask {
-                                    bounds: path.content_mask.bounds,
+                        // todo(linux): group by texture ID
+                        for path in paths {
+                            let tile = &self.path_tiles[&path.id];
+                            let tex_info = self.atlas.get_texture_info(tile.texture_id);
+                            let origin = path.bounds.intersect(&path.content_mask.bounds).origin;
+                            let sprites = [PathSprite {
+                                bounds: Bounds {
+                                    origin: origin.map(|p| p.floor()),
+                                    size: tile.bounds.size.map(Into::into),
                                },
-                            }));
-
-                            sprites.push(PathSprite {
-                                bounds: path.bounds,
                                color: path.color,
-                            });
-                        }
+                                tile: (*tile).clone(),
+                            }];

-                        let b_path_vertices =
-                            unsafe { self.instance_belt.alloc_typed(&vertices, &self.gpu) };
-                        let instance_buf =
-                            unsafe { self.instance_belt.alloc_typed(&sprites, &self.gpu) };
-                        let indirect_buf = unsafe {
-                            self.instance_belt
-                                .alloc_typed(&draw_indirect_commands, &self.gpu)
-                        };
-
-                        encoder.bind(
-                            0,
-                            &ShaderPathsData {
-                                globals,
-                                b_path_vertices,
-                                b_path_sprites: instance_buf,
-                            },
-                        );
-
-                        for i in 0..paths.len() {
-                            encoder.draw_indirect(indirect_buf.buffer.at(indirect_buf.offset
-                                + (i * mem::size_of::<DrawIndirectArgs>()) as u64));
+                            let instance_buf =
+                                unsafe { self.instance_belt.alloc_typed(&sprites, &self.gpu) };
+                            encoder.bind(
+                                0,
+                                &ShaderPathsData {
+                                    globals,
+                                    t_sprite: tex_info.raw_view,
+                                    s_sprite: self.atlas_sampler,
+                                    b_path_sprites: instance_buf,
+                                },
+                            );
+                            encoder.draw(0, 4, 0, sprites.len() as u32);
                        }
                    }
                    PrimitiveBatch::Underlines(underlines) => {
@@ -823,47 +817,9 @@ impl BladeRenderer {
        profiling::scope!("finish");
        self.instance_belt.flush(&sync_point);
        self.atlas.after_frame(&sync_point);
+        self.atlas.clear_textures(AtlasTextureKind::Path);

        self.wait_for_gpu();
        self.last_sync_point = Some(sync_point);
    }
 }
-
-fn create_msaa_texture_if_needed(
-    gpu: &gpu::Context,
-    format: gpu::TextureFormat,
-    width: u32,
-    height: u32,
-    sample_count: u32,
-) -> Option<(gpu::Texture, gpu::TextureView)> {
-    if sample_count <= 1 {
-        return None;
-    }
-
-    let texture_msaa = gpu.create_texture(gpu::TextureDesc {
-        name: "msaa",
-        format,
-        size: gpu::Extent {
-            width,
-            height,
-            depth: 1,
-        },
-        array_layer_count: 1,
-        mip_level_count: 1,
-        sample_count,
-        dimension: gpu::TextureDimension::D2,
-        usage: gpu::TextureUsage::TARGET,
-        external: None,
-    });
-    let texture_view_msaa = gpu.create_texture_view(
-        texture_msaa,
-        gpu::TextureViewDesc {
-            name: "msaa view",
-            format,
-            dimension: gpu::ViewDimension::D2,
-            subresources: &Default::default(),
-        },
-    );
-
-    Some((texture_msaa, texture_view_msaa))
-}
--- a/crates/gpui/src/platform/blade/shaders.wgsl
+++ b/crates/gpui/src/platform/blade/shaders.wgsl
@@ -922,23 +922,59 @@ fn fs_shadow(input: ShadowVarying) -> @location(0) vec4<f32> {
    return blend_color(input.color, alpha);
 }

-// --- paths --- //
+// --- path rasterization --- //

 struct PathVertex {
    xy_position: vec2<f32>,
+    st_position: vec2<f32>,
    content_mask: Bounds,
 }
+var<storage, read> b_path_vertices: array<PathVertex>;
+
+struct PathRasterizationVarying {
+    @builtin(position) position: vec4<f32>,
+    @location(0) st_position: vec2<f32>,
+    //TODO: use `clip_distance` once Naga supports it
+    @location(3) clip_distances: vec4<f32>,
+}
+
+@vertex
+fn vs_path_rasterization(@builtin(vertex_index) vertex_id: u32) -> PathRasterizationVarying {
+    let v = b_path_vertices[vertex_id];
+
+    var out = PathRasterizationVarying();
+    out.position = to_device_position_impl(v.xy_position);
+    out.st_position = v.st_position;
+    out.clip_distances = distance_from_clip_rect_impl(v.xy_position, v.content_mask);
+    return out;
+}
+
+@fragment
+fn fs_path_rasterization(input: PathRasterizationVarying) -> @location(0) f32 {
+    let dx = dpdx(input.st_position);
+    let dy = dpdy(input.st_position);
+    if (any(input.clip_distances < vec4<f32>(0.0))) {
+        return 0.0;
+    }
+
+    let gradient = 2.0 * input.st_position.xx * vec2<f32>(dx.x, dy.x) - vec2<f32>(dx.y, dy.y);
+    let f = input.st_position.x * input.st_position.x - input.st_position.y;
+    let distance = f / length(gradient);
+    return saturate(0.5 - distance);
+}
+
+// --- paths --- //

 struct PathSprite {
    bounds: Bounds,
    color: Background,
+    tile: AtlasTile,
 }
-var<storage, read> b_path_vertices: array<PathVertex>;
 var<storage, read> b_path_sprites: array<PathSprite>;

 struct PathVarying {
    @builtin(position) position: vec4<f32>,
-    @location(0) clip_distances: vec4<f32>,
+    @location(0) tile_position: vec2<f32>,
    @location(1) @interpolate(flat) instance_id: u32,
    @location(2) @interpolate(flat) color_solid: vec4<f32>,
    @location(3) @interpolate(flat) color0: vec4<f32>,
@@ -947,12 +983,13 @@ struct PathVarying {

@vertex
 fn vs_path(@builtin(vertex_index) vertex_id: u32, @builtin(instance_index) instance_id: u32) -> PathVarying {
-    let v = b_path_vertices[vertex_id];
+    let unit_vertex = vec2<f32>(f32(vertex_id & 1u), 0.5 * f32(vertex_id & 2u));
    let sprite = b_path_sprites[instance_id];
+    // Don't apply content mask because it was already accounted for when rasterizing the path.

    var out = PathVarying();
-    out.position = to_device_position_impl(v.xy_position);
-    out.clip_distances = distance_from_clip_rect_impl(v.xy_position, v.content_mask);
+    out.position = to_device_position(unit_vertex, sprite.bounds);
+    out.tile_position = to_tile_position(unit_vertex, sprite.tile);
    out.instance_id = instance_id;

    let gradient = prepare_gradient_color(
@@ -969,15 +1006,13 @@ fn vs_path(@builtin(vertex_index) vertex_id: u32, @builtin(instance_index) insta

@fragment
 fn fs_path(input: PathVarying) -> @location(0) vec4<f32> {
-    if any(input.clip_distances < vec4<f32>(0.0)) {
-        return vec4<f32>(0.0);
-    }
-
+    let sample = textureSample(t_sprite, s_sprite, input.tile_position).r;
+    let mask = 1.0 - abs(1.0 - sample % 2.0);
    let sprite = b_path_sprites[input.instance_id];
    let background = sprite.color;
    let color = gradient_color(background, input.position.xy, sprite.bounds,
        input.color_solid, input.color0, input.color1);
-    return blend_color(color, 1.0);
+    return blend_color(color, mask);
 }

 // --- underlines --- //
--- a/crates/gpui/src/platform/keystroke.rs
+++ b/crates/gpui/src/platform/keystroke.rs
@@ -417,6 +417,17 @@ impl Modifiers {
        self.control || self.alt || self.shift || self.platform || self.function
    }

+    /// Returns the XOR of two modifier sets
+    pub fn xor(&self, other: &Modifiers) -> Modifiers {
+        Modifiers {
+            control: self.control ^ other.control,
+            alt: self.alt ^ other.alt,
+            shift: self.shift ^ other.shift,
+            platform: self.platform ^ other.platform,
+            function: self.function ^ other.function,
+        }
+    }
+
    /// Whether the semantically 'secondary' modifier key is pressed.
    ///
    /// On macOS, this is the command key.
--- a/crates/gpui/src/platform/linux/platform.rs
+++ b/crates/gpui/src/platform/linux/platform.rs
@@ -822,11 +822,28 @@ impl crate::Keystroke {
            Keysym::underscore => "_".to_owned(),
            Keysym::equal => "=".to_owned(),
            Keysym::plus => "+".to_owned(),
+            Keysym::space => "space".to_owned(),
+            Keysym::BackSpace => "backspace".to_owned(),
+            Keysym::Tab => "tab".to_owned(),
+            Keysym::Delete => "delete".to_owned(),
+            Keysym::Escape => "escape".to_owned(),

            _ => {
                let name = xkb::keysym_get_name(key_sym).to_lowercase();
                if key_sym.is_keypad_key() {
                    name.replace("kp_", "")
+                } else if let Some(key) = key_utf8.chars().next()
+                    && key_utf8.len() == 1
+                    && key.is_ascii()
+                {
+                    if key.is_ascii_graphic() {
+                        key_utf8.to_lowercase()
+                    // map ctrl-a to a
+                    } else if key_utf32 <= 0x1f {
+                        ((key_utf32 as u8 + 0x60) as char).to_string()
+                    } else {
+                        name
+                    }
                } else if let Some(key_en) = guess_ascii(keycode, modifiers.shift) {
                    String::from(key_en)
                } else {
--- a/crates/gpui/src/platform/linux/x11/client.rs
+++ b/crates/gpui/src/platform/linux/x11/client.rs
@@ -1,5 +1,14 @@
 use crate::{Capslock, xcb_flush};
+use anyhow::{Context as _, anyhow};
+use calloop::{
+    EventLoop, LoopHandle, RegistrationToken,
+    generic::{FdWrapper, Generic},
+};
+use collections::HashMap;
 use core::str;
+use http_client::Url;
+use log::Level;
+use smallvec::SmallVec;
 use std::{
    cell::RefCell,
    collections::{BTreeMap, HashSet},
@@ -8,16 +17,6 @@ use std::{
    rc::{Rc, Weak},
    time::{Duration, Instant},
 };
-
-use anyhow::{Context as _, anyhow};
-use calloop::{
-    EventLoop, LoopHandle, RegistrationToken,
-    generic::{FdWrapper, Generic},
-};
-use collections::HashMap;
-use http_client::Url;
-use log::Level;
-use smallvec::SmallVec;
 use util::ResultExt;

 use x11rb::{
@@ -38,7 +37,7 @@ use x11rb::{
 };
 use xim::{AttributeName, Client, InputStyle, x11rb::X11rbClient};
 use xkbc::x11::ffi::{XKB_X11_MIN_MAJOR_XKB_VERSION, XKB_X11_MIN_MINOR_XKB_VERSION};
-use xkbcommon::xkb::{self as xkbc, LayoutIndex, ModMask, STATE_LAYOUT_EFFECTIVE};
+use xkbcommon::xkb::{self as xkbc, STATE_LAYOUT_EFFECTIVE};

 use super::{
    ButtonOrScroll, ScrollDirection, X11Display, X11WindowStatePtr, XcbAtoms, XimCallbackEvent,
@@ -141,13 +140,6 @@ impl From<xim::ClientError> for EventHandlerError {
    }
 }

-#[derive(Debug, Default, Clone)]
-struct XKBStateNotiy {
-    depressed_layout: LayoutIndex,
-    latched_layout: LayoutIndex,
-    locked_layout: LayoutIndex,
-}
-
 #[derive(Debug, Default)]
 pub struct Xdnd {
    other_window: xproto::Window,
@@ -200,7 +192,6 @@ pub struct X11ClientState {
    pub(crate) mouse_focused_window: Option<xproto::Window>,
    pub(crate) keyboard_focused_window: Option<xproto::Window>,
    pub(crate) xkb: xkbc::State,
-    previous_xkb_state: XKBStateNotiy,
    keyboard_layout: LinuxKeyboardLayout,
    pub(crate) ximc: Option<X11rbClient<Rc<XCBConnection>>>,
    pub(crate) xim_handler: Option<XimHandler>,
@@ -507,7 +498,6 @@ impl X11Client {
            mouse_focused_window: None,
            keyboard_focused_window: None,
            xkb: xkb_state,
-            previous_xkb_state: XKBStateNotiy::default(),
            keyboard_layout,
            ximc,
            xim_handler,
@@ -959,14 +949,6 @@ impl X11Client {
                        state.xkb_device_id,
                    )
                };
-                let depressed_layout = xkb_state.serialize_layout(xkbc::STATE_LAYOUT_DEPRESSED);
-                let latched_layout = xkb_state.serialize_layout(xkbc::STATE_LAYOUT_LATCHED);
-                let locked_layout = xkb_state.serialize_layout(xkbc::ffi::XKB_STATE_LAYOUT_LOCKED);
-                state.previous_xkb_state = XKBStateNotiy {
-                    depressed_layout,
-                    latched_layout,
-                    locked_layout,
-                };
                state.xkb = xkb_state;
                drop(state);
                self.handle_keyboard_layout_change();
@@ -983,12 +965,6 @@ impl X11Client {
                    event.latched_group as u32,
                    event.locked_group.into(),
                );
-                state.previous_xkb_state = XKBStateNotiy {
-                    depressed_layout: event.base_group as u32,
-                    latched_layout: event.latched_group as u32,
-                    locked_layout: event.locked_group.into(),
-                };
-
                let modifiers = Modifiers::from_xkb(&state.xkb);
                let capslock = Capslock::from_xkb(&state.xkb);
                if state.last_modifiers_changed_event == modifiers
@@ -1025,17 +1001,12 @@ impl X11Client {
                state.pre_key_char_down.take();
                let keystroke = {
                    let code = event.detail.into();
-                    let xkb_state = state.previous_xkb_state.clone();
-                    state.xkb.update_mask(
-                        event.state.bits() as ModMask,
-                        0,
-                        0,
-                        xkb_state.depressed_layout,
-                        xkb_state.latched_layout,
-                        xkb_state.locked_layout,
-                    );
                    let mut keystroke = crate::Keystroke::from_xkb(&state.xkb, modifiers, code);
                    let keysym = state.xkb.key_get_one_sym(code);
+
+                    // should be called after key_get_one_sym
+                    state.xkb.update_key(code, xkbc::KeyDirection::Down);
+
                    if keysym.is_modifier_key() {
                        return Some(());
                    }
@@ -1093,17 +1064,12 @@ impl X11Client {

                let keystroke = {
                    let code = event.detail.into();
-                    let xkb_state = state.previous_xkb_state.clone();
-                    state.xkb.update_mask(
-                        event.state.bits() as ModMask,
-                        0,
-                        0,
-                        xkb_state.depressed_layout,
-                        xkb_state.latched_layout,
-                        xkb_state.locked_layout,
-                    );
                    let keystroke = crate::Keystroke::from_xkb(&state.xkb, modifiers, code);
                    let keysym = state.xkb.key_get_one_sym(code);
+
+                    // should be called after key_get_one_sym
+                    state.xkb.update_key(code, xkbc::KeyDirection::Up);
+
                    if keysym.is_modifier_key() {
                        return Some(());
                    }
--- a/crates/gpui/src/platform/mac/metal_atlas.rs
+++ b/crates/gpui/src/platform/mac/metal_atlas.rs
@@ -13,12 +13,14 @@ use std::borrow::Cow;
 pub(crate) struct MetalAtlas(Mutex<MetalAtlasState>);

 impl MetalAtlas {
-    pub(crate) fn new(device: Device) -> Self {
+    pub(crate) fn new(device: Device, path_sample_count: u32) -> Self {
        MetalAtlas(Mutex::new(MetalAtlasState {
            device: AssertSend(device),
            monochrome_textures: Default::default(),
            polychrome_textures: Default::default(),
+            path_textures: Default::default(),
            tiles_by_key: Default::default(),
+            path_sample_count,
        }))
    }

@@ -26,7 +28,10 @@ impl MetalAtlas {
        self.0.lock().texture(id).metal_texture.clone()
    }

-    #[allow(dead_code)]
+    pub(crate) fn msaa_texture(&self, id: AtlasTextureId) -> Option<metal::Texture> {
+        self.0.lock().texture(id).msaa_texture.clone()
+    }
+
    pub(crate) fn allocate(
        &self,
        size: Size<DevicePixels>,
@@ -35,12 +40,12 @@ impl MetalAtlas {
        self.0.lock().allocate(size, texture_kind)
    }

-    #[allow(dead_code)]
    pub(crate) fn clear_textures(&self, texture_kind: AtlasTextureKind) {
        let mut lock = self.0.lock();
        let textures = match texture_kind {
            AtlasTextureKind::Monochrome => &mut lock.monochrome_textures,
            AtlasTextureKind::Polychrome => &mut lock.polychrome_textures,
+            AtlasTextureKind::Path => &mut lock.path_textures,
        };
        for texture in textures.iter_mut() {
            texture.clear();
@@ -52,7 +57,9 @@ struct MetalAtlasState {
    device: AssertSend<Device>,
    monochrome_textures: AtlasTextureList<MetalAtlasTexture>,
    polychrome_textures: AtlasTextureList<MetalAtlasTexture>,
+    path_textures: AtlasTextureList<MetalAtlasTexture>,
    tiles_by_key: FxHashMap<AtlasKey, AtlasTile>,
+    path_sample_count: u32,
 }

 impl PlatformAtlas for MetalAtlas {
@@ -87,6 +94,7 @@ impl PlatformAtlas for MetalAtlas {
        let textures = match id.kind {
            AtlasTextureKind::Monochrome => &mut lock.monochrome_textures,
            AtlasTextureKind::Polychrome => &mut lock.polychrome_textures,
+            AtlasTextureKind::Path => &mut lock.polychrome_textures,
        };

        let Some(texture_slot) = textures
@@ -120,6 +128,7 @@ impl MetalAtlasState {
            let textures = match texture_kind {
                AtlasTextureKind::Monochrome => &mut self.monochrome_textures,
                AtlasTextureKind::Polychrome => &mut self.polychrome_textures,
+                AtlasTextureKind::Path => &mut self.path_textures,
            };

            if let Some(tile) = textures
@@ -164,14 +173,31 @@ impl MetalAtlasState {
                pixel_format = metal::MTLPixelFormat::BGRA8Unorm;
                usage = metal::MTLTextureUsage::ShaderRead;
            }
+            AtlasTextureKind::Path => {
+                pixel_format = metal::MTLPixelFormat::R16Float;
+                usage = metal::MTLTextureUsage::RenderTarget | metal::MTLTextureUsage::ShaderRead;
+            }
        }
        texture_descriptor.set_pixel_format(pixel_format);
        texture_descriptor.set_usage(usage);
        let metal_texture = self.device.new_texture(&texture_descriptor);

+        // We currently only enable MSAA for path textures.
+        let msaa_texture = if self.path_sample_count > 1 && kind == AtlasTextureKind::Path {
+            let mut descriptor = texture_descriptor.clone();
+            descriptor.set_texture_type(metal::MTLTextureType::D2Multisample);
+            descriptor.set_storage_mode(metal::MTLStorageMode::Private);
+            descriptor.set_sample_count(self.path_sample_count as _);
+            let msaa_texture = self.device.new_texture(&descriptor);
+            Some(msaa_texture)
+        } else {
+            None
+        };
+
        let texture_list = match kind {
            AtlasTextureKind::Monochrome => &mut self.monochrome_textures,
            AtlasTextureKind::Polychrome => &mut self.polychrome_textures,
+            AtlasTextureKind::Path => &mut self.path_textures,
        };

        let index = texture_list.free_list.pop();
@@ -183,6 +209,7 @@ impl MetalAtlasState {
            },
            allocator: etagere::BucketedAtlasAllocator::new(size.into()),
            metal_texture: AssertSend(metal_texture),
+            msaa_texture: AssertSend(msaa_texture),
            live_atlas_keys: 0,
        };

@@ -199,6 +226,7 @@ impl MetalAtlasState {
        let textures = match id.kind {
            crate::AtlasTextureKind::Monochrome => &self.monochrome_textures,
            crate::AtlasTextureKind::Polychrome => &self.polychrome_textures,
+            crate::AtlasTextureKind::Path => &self.path_textures,
        };
        textures[id.index as usize].as_ref().unwrap()
    }
@@ -208,6 +236,7 @@ struct MetalAtlasTexture {
    id: AtlasTextureId,
    allocator: BucketedAtlasAllocator,
    metal_texture: AssertSend<metal::Texture>,
+    msaa_texture: AssertSend<Option<metal::Texture>>,
    live_atlas_keys: u32,
 }

--- a/crates/gpui/src/platform/mac/metal_renderer.rs
+++ b/crates/gpui/src/platform/mac/metal_renderer.rs
@@ -1,28 +1,27 @@
 use super::metal_atlas::MetalAtlas;
 use crate::{
-    AtlasTextureId, Background, Bounds, ContentMask, DevicePixels, MonochromeSprite, PaintSurface,
-    Path, PathVertex, PolychromeSprite, PrimitiveBatch, Quad, ScaledPixels, Scene, Shadow, Size,
-    Surface, Underline, point, size,
+    AtlasTextureId, AtlasTextureKind, AtlasTile, Background, Bounds, ContentMask, DevicePixels,
+    MonochromeSprite, PaintSurface, Path, PathId, PathVertex, PolychromeSprite, PrimitiveBatch,
+    Quad, ScaledPixels, Scene, Shadow, Size, Surface, Underline, point, size,
 };
-use anyhow::Result;
+use anyhow::{Context as _, Result};
 use block::ConcreteBlock;
 use cocoa::{
    base::{NO, YES},
    foundation::{NSSize, NSUInteger},
    quartzcore::AutoresizingMask,
 };
+use collections::HashMap;
 use core_foundation::base::TCFType;
 use core_video::{
    metal_texture::CVMetalTextureGetTexture, metal_texture_cache::CVMetalTextureCache,
    pixel_buffer::kCVPixelFormatType_420YpCbCr8BiPlanarFullRange,
 };
 use foreign_types::{ForeignType, ForeignTypeRef};
-use metal::{
-    CAMetalLayer, CommandQueue, MTLDrawPrimitivesIndirectArguments, MTLPixelFormat,
-    MTLResourceOptions, NSRange,
-};
+use metal::{CAMetalLayer, CommandQueue, MTLPixelFormat, MTLResourceOptions, NSRange};
 use objc::{self, msg_send, sel, sel_impl};
 use parking_lot::Mutex;
+use smallvec::SmallVec;
 use std::{cell::Cell, ffi::c_void, mem, ptr, sync::Arc};

 // Exported to metal
@@ -32,6 +31,9 @@ pub(crate) type PointF = crate::Point<f32>;
 const SHADERS_METALLIB: &[u8] = include_bytes!(concat!(env!("OUT_DIR"), "/shaders.metallib"));
 #[cfg(feature = "runtime_shaders")]
 const SHADERS_SOURCE_FILE: &str = include_str!(concat!(env!("OUT_DIR"), "/stitched_shaders.metal"));
+// Use 4x MSAA, all devices support it.
+// https://developer.apple.com/documentation/metal/mtldevice/1433355-supportstexturesamplecount
+const PATH_SAMPLE_COUNT: u32 = 4;

 pub type Context = Arc<Mutex<InstanceBufferPool>>;
 pub type Renderer = MetalRenderer;
@@ -96,7 +98,8 @@ pub(crate) struct MetalRenderer {
    layer: metal::MetalLayer,
    presents_with_transaction: bool,
    command_queue: CommandQueue,
-    path_pipeline_state: metal::RenderPipelineState,
+    paths_rasterization_pipeline_state: metal::RenderPipelineState,
+    path_sprites_pipeline_state: metal::RenderPipelineState,
    shadows_pipeline_state: metal::RenderPipelineState,
    quads_pipeline_state: metal::RenderPipelineState,
    underlines_pipeline_state: metal::RenderPipelineState,
@@ -108,8 +111,6 @@ pub(crate) struct MetalRenderer {
    instance_buffer_pool: Arc<Mutex<InstanceBufferPool>>,
    sprite_atlas: Arc<MetalAtlas>,
    core_video_texture_cache: core_video::metal_texture_cache::CVMetalTextureCache,
-    sample_count: u64,
-    msaa_texture: Option<metal::Texture>,
 }

 impl MetalRenderer {
@@ -168,19 +169,22 @@ impl MetalRenderer {
            MTLResourceOptions::StorageModeManaged,
        );

-        let sample_count = [4, 2, 1]
-            .into_iter()
-            .find(|count| device.supports_texture_sample_count(*count))
-            .unwrap_or(1);
-
-        let path_pipeline_state = build_pipeline_state(
+        let paths_rasterization_pipeline_state = build_path_rasterization_pipeline_state(
            &device,
            &library,
-            "paths",
-            "path_vertex",
-            "path_fragment",
+            "paths_rasterization",
+            "path_rasterization_vertex",
+            "path_rasterization_fragment",
+            MTLPixelFormat::R16Float,
+            PATH_SAMPLE_COUNT,
+        );
+        let path_sprites_pipeline_state = build_pipeline_state(
+            &device,
+            &library,
+            "path_sprites",
+            "path_sprite_vertex",
+            "path_sprite_fragment",
            MTLPixelFormat::BGRA8Unorm,
-            sample_count,
        );
        let shadows_pipeline_state = build_pipeline_state(
            &device,
@@ -189,7 +193,6 @@ impl MetalRenderer {
            "shadow_vertex",
            "shadow_fragment",
            MTLPixelFormat::BGRA8Unorm,
-            sample_count,
        );
        let quads_pipeline_state = build_pipeline_state(
            &device,
@@ -198,7 +201,6 @@ impl MetalRenderer {
            "quad_vertex",
            "quad_fragment",
            MTLPixelFormat::BGRA8Unorm,
-            sample_count,
        );
        let underlines_pipeline_state = build_pipeline_state(
            &device,
@@ -207,7 +209,6 @@ impl MetalRenderer {
            "underline_vertex",
            "underline_fragment",
            MTLPixelFormat::BGRA8Unorm,
-            sample_count,
        );
        let monochrome_sprites_pipeline_state = build_pipeline_state(
            &device,
@@ -216,7 +217,6 @@ impl MetalRenderer {
            "monochrome_sprite_vertex",
            "monochrome_sprite_fragment",
            MTLPixelFormat::BGRA8Unorm,
-            sample_count,
        );
        let polychrome_sprites_pipeline_state = build_pipeline_state(
            &device,
@@ -225,7 +225,6 @@ impl MetalRenderer {
            "polychrome_sprite_vertex",
            "polychrome_sprite_fragment",
            MTLPixelFormat::BGRA8Unorm,
-            sample_count,
        );
        let surfaces_pipeline_state = build_pipeline_state(
            &device,
@@ -234,21 +233,20 @@ impl MetalRenderer {
            "surface_vertex",
            "surface_fragment",
            MTLPixelFormat::BGRA8Unorm,
-            sample_count,
        );

        let command_queue = device.new_command_queue();
-        let sprite_atlas = Arc::new(MetalAtlas::new(device.clone()));
+        let sprite_atlas = Arc::new(MetalAtlas::new(device.clone(), PATH_SAMPLE_COUNT));
        let core_video_texture_cache =
            CVMetalTextureCache::new(None, device.clone(), None).unwrap();
-        let msaa_texture = create_msaa_texture(&device, &layer, sample_count);

        Self {
            device,
            layer,
            presents_with_transaction: false,
            command_queue,
-            path_pipeline_state,
+            paths_rasterization_pipeline_state,
+            path_sprites_pipeline_state,
            shadows_pipeline_state,
            quads_pipeline_state,
            underlines_pipeline_state,
@@ -259,8 +257,6 @@ impl MetalRenderer {
            instance_buffer_pool,
            sprite_atlas,
            core_video_texture_cache,
-            sample_count,
-            msaa_texture,
        }
    }

@@ -293,8 +289,6 @@ impl MetalRenderer {
                setDrawableSize: size
            ];
        }
-
-        self.msaa_texture = create_msaa_texture(&self.device, &self.layer, self.sample_count);
    }

    pub fn update_transparency(&self, _transparent: bool) {
@@ -381,23 +375,25 @@ impl MetalRenderer {
        let command_queue = self.command_queue.clone();
        let command_buffer = command_queue.new_command_buffer();
        let mut instance_offset = 0;
+
+        let path_tiles = self
+            .rasterize_paths(
+                scene.paths(),
+                instance_buffer,
+                &mut instance_offset,
+                command_buffer,
+            )
+            .with_context(|| format!("rasterizing {} paths", scene.paths().len()))?;
+
        let render_pass_descriptor = metal::RenderPassDescriptor::new();
        let color_attachment = render_pass_descriptor
            .color_attachments()
            .object_at(0)
            .unwrap();

-        if let Some(msaa_texture_ref) = self.msaa_texture.as_deref() {
-            color_attachment.set_texture(Some(msaa_texture_ref));
-            color_attachment.set_load_action(metal::MTLLoadAction::Clear);
-            color_attachment.set_store_action(metal::MTLStoreAction::MultisampleResolve);
-            color_attachment.set_resolve_texture(Some(drawable.texture()));
-        } else {
-            color_attachment.set_load_action(metal::MTLLoadAction::Clear);
-            color_attachment.set_texture(Some(drawable.texture()));
-            color_attachment.set_store_action(metal::MTLStoreAction::Store);
-        }
-
+        color_attachment.set_texture(Some(drawable.texture()));
+        color_attachment.set_load_action(metal::MTLLoadAction::Clear);
+        color_attachment.set_store_action(metal::MTLStoreAction::Store);
        let alpha = if self.layer.is_opaque() { 1. } else { 0. };
        color_attachment.set_clear_color(metal::MTLClearColor::new(0., 0., 0., alpha));
        let command_encoder = command_buffer.new_render_command_encoder(render_pass_descriptor);
@@ -429,6 +425,7 @@ impl MetalRenderer {
                ),
                PrimitiveBatch::Paths(paths) => self.draw_paths(
                    paths,
+                    &path_tiles,
                    instance_buffer,
                    &mut instance_offset,
                    viewport_size,
@@ -496,6 +493,106 @@ impl MetalRenderer {
        Ok(command_buffer.to_owned())
    }

+    fn rasterize_paths(
+        &self,
+        paths: &[Path<ScaledPixels>],
+        instance_buffer: &mut InstanceBuffer,
+        instance_offset: &mut usize,
+        command_buffer: &metal::CommandBufferRef,
+    ) -> Option<HashMap<PathId, AtlasTile>> {
+        self.sprite_atlas.clear_textures(AtlasTextureKind::Path);
+
+        let mut tiles = HashMap::default();
+        let mut vertices_by_texture_id = HashMap::default();
+        for path in paths {
+            let clipped_bounds = path.bounds.intersect(&path.content_mask.bounds);
+
+            let tile = self
+                .sprite_atlas
+                .allocate(clipped_bounds.size.map(Into::into), AtlasTextureKind::Path)?;
+            vertices_by_texture_id
+                .entry(tile.texture_id)
+                .or_insert(Vec::new())
+                .extend(path.vertices.iter().map(|vertex| PathVertex {
+                    xy_position: vertex.xy_position - clipped_bounds.origin
+                        + tile.bounds.origin.map(Into::into),
+                    st_position: vertex.st_position,
+                    content_mask: ContentMask {
+                        bounds: tile.bounds.map(Into::into),
+                    },
+                }));
+            tiles.insert(path.id, tile);
+        }
+
+        for (texture_id, vertices) in vertices_by_texture_id {
+            align_offset(instance_offset);
+            let vertices_bytes_len = mem::size_of_val(vertices.as_slice());
+            let next_offset = *instance_offset + vertices_bytes_len;
+            if next_offset > instance_buffer.size {
+                return None;
+            }
+
+            let render_pass_descriptor = metal::RenderPassDescriptor::new();
+            let color_attachment = render_pass_descriptor
+                .color_attachments()
+                .object_at(0)
+                .unwrap();
+
+            let texture = self.sprite_atlas.metal_texture(texture_id);
+            let msaa_texture = self.sprite_atlas.msaa_texture(texture_id);
+
+            if let Some(msaa_texture) = msaa_texture {
+                color_attachment.set_texture(Some(&msaa_texture));
+                color_attachment.set_resolve_texture(Some(&texture));
+                color_attachment.set_load_action(metal::MTLLoadAction::Clear);
+                color_attachment.set_store_action(metal::MTLStoreAction::MultisampleResolve);
+            } else {
+                color_attachment.set_texture(Some(&texture));
+                color_attachment.set_load_action(metal::MTLLoadAction::Clear);
+                color_attachment.set_store_action(metal::MTLStoreAction::Store);
+            }
+            color_attachment.set_clear_color(metal::MTLClearColor::new(0., 0., 0., 1.));
+
+            let command_encoder = command_buffer.new_render_command_encoder(render_pass_descriptor);
+            command_encoder.set_render_pipeline_state(&self.paths_rasterization_pipeline_state);
+            command_encoder.set_vertex_buffer(
+                PathRasterizationInputIndex::Vertices as u64,
+                Some(&instance_buffer.metal_buffer),
+                *instance_offset as u64,
+            );
+            let texture_size = Size {
+                width: DevicePixels::from(texture.width()),
+                height: DevicePixels::from(texture.height()),
+            };
+            command_encoder.set_vertex_bytes(
+                PathRasterizationInputIndex::AtlasTextureSize as u64,
+                mem::size_of_val(&texture_size) as u64,
+                &texture_size as *const Size<DevicePixels> as *const _,
+            );
+
+            let buffer_contents = unsafe {
+                (instance_buffer.metal_buffer.contents() as *mut u8).add(*instance_offset)
+            };
+            unsafe {
+                ptr::copy_nonoverlapping(
+                    vertices.as_ptr() as *const u8,
+                    buffer_contents,
+                    vertices_bytes_len,
+                );
+            }
+
+            command_encoder.draw_primitives(
+                metal::MTLPrimitiveType::Triangle,
+                0,
+                vertices.len() as u64,
+            );
+            command_encoder.end_encoding();
+            *instance_offset = next_offset;
+        }
+
+        Some(tiles)
+    }
+
    fn draw_shadows(
        &self,
        shadows: &[Shadow],
@@ -621,6 +718,7 @@ impl MetalRenderer {
    fn draw_paths(
        &self,
        paths: &[Path<ScaledPixels>],
+        tiles_by_path_id: &HashMap<PathId, AtlasTile>,
        instance_buffer: &mut InstanceBuffer,
        instance_offset: &mut usize,
        viewport_size: Size<DevicePixels>,
@@ -630,108 +728,100 @@ impl MetalRenderer {
            return true;
        }

-        command_encoder.set_render_pipeline_state(&self.path_pipeline_state);
+        command_encoder.set_render_pipeline_state(&self.path_sprites_pipeline_state);
+        command_encoder.set_vertex_buffer(
+            SpriteInputIndex::Vertices as u64,
+            Some(&self.unit_vertices),
+            0,
+        );
+        command_encoder.set_vertex_bytes(
+            SpriteInputIndex::ViewportSize as u64,
+            mem::size_of_val(&viewport_size) as u64,
+            &viewport_size as *const Size<DevicePixels> as *const _,
+        );

-        unsafe {
-            let base_addr = instance_buffer.metal_buffer.contents();
-            let mut p = (base_addr as *mut u8).add(*instance_offset);
-            let mut draw_indirect_commands = Vec::with_capacity(paths.len());
+        let mut prev_texture_id = None;
+        let mut sprites = SmallVec::<[_; 1]>::new();
+        let mut paths_and_tiles = paths
+            .iter()
+            .map(|path| (path, tiles_by_path_id.get(&path.id).unwrap()))
+            .peekable();

-            // copy vertices
-            let vertices_offset = (p as usize) - (base_addr as usize);
-            let mut first_vertex = 0;
-            for (i, path) in paths.iter().enumerate() {
-                if (p as usize) - (base_addr as usize)
-                    + (mem::size_of::<PathVertex<ScaledPixels>>() * path.vertices.len())
-                    > instance_buffer.size
-                {
+        loop {
+            if let Some((path, tile)) = paths_and_tiles.peek() {
+                if prev_texture_id.map_or(true, |texture_id| texture_id == tile.texture_id) {
+                    prev_texture_id = Some(tile.texture_id);
+                    let origin = path.bounds.intersect(&path.content_mask.bounds).origin;
+                    sprites.push(PathSprite {
+                        bounds: Bounds {
+                            origin: origin.map(|p| p.floor()),
+                            size: tile.bounds.size.map(Into::into),
+                        },
+                        color: path.color,
+                        tile: (*tile).clone(),
+                    });
+                    paths_and_tiles.next();
+                    continue;
+                }
+            }
+
+            if sprites.is_empty() {
+                break;
+            } else {
+                align_offset(instance_offset);
+                let texture_id = prev_texture_id.take().unwrap();
+                let texture: metal::Texture = self.sprite_atlas.metal_texture(texture_id);
+                let texture_size = size(
+                    DevicePixels(texture.width() as i32),
+                    DevicePixels(texture.height() as i32),
+                );
+
+                command_encoder.set_vertex_buffer(
+                    SpriteInputIndex::Sprites as u64,
+                    Some(&instance_buffer.metal_buffer),
+                    *instance_offset as u64,
+                );
+                command_encoder.set_vertex_bytes(
+                    SpriteInputIndex::AtlasTextureSize as u64,
+                    mem::size_of_val(&texture_size) as u64,
+                    &texture_size as *const Size<DevicePixels> as *const _,
+                );
+                command_encoder.set_fragment_buffer(
+                    SpriteInputIndex::Sprites as u64,
+                    Some(&instance_buffer.metal_buffer),
+                    *instance_offset as u64,
+                );
+                command_encoder
+                    .set_fragment_texture(SpriteInputIndex::AtlasTexture as u64, Some(&texture));
+
+                let sprite_bytes_len = mem::size_of_val(sprites.as_slice());
+                let next_offset = *instance_offset + sprite_bytes_len;
+                if next_offset > instance_buffer.size {
                    return false;
                }

-                for v in &path.vertices {
-                    *(p as *mut PathVertex<ScaledPixels>) = PathVertex {
-                        xy_position: v.xy_position,
-                        content_mask: ContentMask {
-                            bounds: path.content_mask.bounds,
-                        },
-                    };
-                    p = p.add(mem::size_of::<PathVertex<ScaledPixels>>());
+                let buffer_contents = unsafe {
+                    (instance_buffer.metal_buffer.contents() as *mut u8).add(*instance_offset)
+                };
+
+                unsafe {
+                    ptr::copy_nonoverlapping(
+                        sprites.as_ptr() as *const u8,
+                        buffer_contents,
+                        sprite_bytes_len,
+                    );
                }

-                draw_indirect_commands.push(MTLDrawPrimitivesIndirectArguments {
-                    vertexCount: path.vertices.len() as u32,
-                    instanceCount: 1,
-                    vertexStart: first_vertex,
-                    baseInstance: i as u32,
-                });
-                first_vertex += path.vertices.len() as u32;
-            }
-
-            // copy sprites
-            let sprites_offset = (p as u64) - (base_addr as u64);
-            if (p as usize) - (base_addr as usize) + (mem::size_of::<PathSprite>() * paths.len())
-                > instance_buffer.size
-            {
-                return false;
-            }
-            for path in paths {
-                *(p as *mut PathSprite) = PathSprite {
-                    bounds: path.bounds,
-                    color: path.color,
-                };
-                p = p.add(mem::size_of::<PathSprite>());
-            }
-
-            // copy indirect commands
-            let icb_bytes_len = mem::size_of_val(draw_indirect_commands.as_slice());
-            let icb_offset = (p as u64) - (base_addr as u64);
-            if (p as usize) - (base_addr as usize) + icb_bytes_len > instance_buffer.size {
-                return false;
-            }
-            ptr::copy_nonoverlapping(
-                draw_indirect_commands.as_ptr() as *const u8,
-                p,
-                icb_bytes_len,
-            );
-            p = p.add(icb_bytes_len);
-
-            // draw path
-            command_encoder.set_vertex_buffer(
-                PathInputIndex::Vertices as u64,
-                Some(&instance_buffer.metal_buffer),
-                vertices_offset as u64,
-            );
-
-            command_encoder.set_vertex_bytes(
-                PathInputIndex::ViewportSize as u64,
-                mem::size_of_val(&viewport_size) as u64,
-                &viewport_size as *const Size<DevicePixels> as *const _,
-            );
-
-            command_encoder.set_vertex_buffer(
-                PathInputIndex::Sprites as u64,
-                Some(&instance_buffer.metal_buffer),
-                sprites_offset,
-            );
-
-            command_encoder.set_fragment_buffer(
-                PathInputIndex::Sprites as u64,
-                Some(&instance_buffer.metal_buffer),
-                sprites_offset,
-            );
-
-            for i in 0..paths.len() {
-                command_encoder.draw_primitives_indirect(
+                command_encoder.draw_primitives_instanced(
                    metal::MTLPrimitiveType::Triangle,
-                    &instance_buffer.metal_buffer,
-                    icb_offset
-                        + (i * std::mem::size_of::<MTLDrawPrimitivesIndirectArguments>()) as u64,
+                    0,
+                    6,
+                    sprites.len() as u64,
                );
+                *instance_offset = next_offset;
+                sprites.clear();
            }
-
-            *instance_offset = (p as usize) - (base_addr as usize);
        }
-
        true
    }

@@ -1053,7 +1143,6 @@ fn build_pipeline_state(
    vertex_fn_name: &str,
    fragment_fn_name: &str,
    pixel_format: metal::MTLPixelFormat,
-    sample_count: u64,
 ) -> metal::RenderPipelineState {
    let vertex_fn = library
        .get_function(vertex_fn_name, None)
@@ -1066,7 +1155,6 @@ fn build_pipeline_state(
    descriptor.set_label(label);
    descriptor.set_vertex_function(Some(vertex_fn.as_ref()));
    descriptor.set_fragment_function(Some(fragment_fn.as_ref()));
-    descriptor.set_sample_count(sample_count);
    let color_attachment = descriptor.color_attachments().object_at(0).unwrap();
    color_attachment.set_pixel_format(pixel_format);
    color_attachment.set_blending_enabled(true);
@@ -1082,45 +1170,50 @@ fn build_pipeline_state(
        .expect("could not create render pipeline state")
 }

+fn build_path_rasterization_pipeline_state(
+    device: &metal::DeviceRef,
+    library: &metal::LibraryRef,
+    label: &str,
+    vertex_fn_name: &str,
+    fragment_fn_name: &str,
+    pixel_format: metal::MTLPixelFormat,
+    path_sample_count: u32,
+) -> metal::RenderPipelineState {
+    let vertex_fn = library
+        .get_function(vertex_fn_name, None)
+        .expect("error locating vertex function");
+    let fragment_fn = library
+        .get_function(fragment_fn_name, None)
+        .expect("error locating fragment function");
+
+    let descriptor = metal::RenderPipelineDescriptor::new();
+    descriptor.set_label(label);
+    descriptor.set_vertex_function(Some(vertex_fn.as_ref()));
+    descriptor.set_fragment_function(Some(fragment_fn.as_ref()));
+    if path_sample_count > 1 {
+        descriptor.set_raster_sample_count(path_sample_count as _);
+        descriptor.set_alpha_to_coverage_enabled(true);
+    }
+    let color_attachment = descriptor.color_attachments().object_at(0).unwrap();
+    color_attachment.set_pixel_format(pixel_format);
+    color_attachment.set_blending_enabled(true);
+    color_attachment.set_rgb_blend_operation(metal::MTLBlendOperation::Add);
+    color_attachment.set_alpha_blend_operation(metal::MTLBlendOperation::Add);
+    color_attachment.set_source_rgb_blend_factor(metal::MTLBlendFactor::One);
+    color_attachment.set_source_alpha_blend_factor(metal::MTLBlendFactor::One);
+    color_attachment.set_destination_rgb_blend_factor(metal::MTLBlendFactor::One);
+    color_attachment.set_destination_alpha_blend_factor(metal::MTLBlendFactor::One);
+
+    device
+        .new_render_pipeline_state(&descriptor)
+        .expect("could not create render pipeline state")
+}
+
 // Align to multiples of 256 make Metal happy.
 fn align_offset(offset: &mut usize) {
    *offset = (*offset).div_ceil(256) * 256;
 }

-fn create_msaa_texture(
-    device: &metal::Device,
-    layer: &metal::MetalLayer,
-    sample_count: u64,
-) -> Option<metal::Texture> {
-    let viewport_size = layer.drawable_size();
-    let width = viewport_size.width.ceil() as u64;
-    let height = viewport_size.height.ceil() as u64;
-
-    if width == 0 || height == 0 {
-        return None;
-    }
-
-    if sample_count <= 1 {
-        return None;
-    }
-
-    let texture_descriptor = metal::TextureDescriptor::new();
-    texture_descriptor.set_texture_type(metal::MTLTextureType::D2Multisample);
-
-    // MTLStorageMode default is `shared` only for Apple silicon GPUs. Use `private` for Apple and Intel GPUs both.
-    // Reference: https://developer.apple.com/documentation/metal/choosing-a-resource-storage-mode-for-apple-gpus
-    texture_descriptor.set_storage_mode(metal::MTLStorageMode::Private);
-
-    texture_descriptor.set_width(width);
-    texture_descriptor.set_height(height);
-    texture_descriptor.set_pixel_format(layer.pixel_format());
-    texture_descriptor.set_usage(metal::MTLTextureUsage::RenderTarget);
-    texture_descriptor.set_sample_count(sample_count);
-
-    let metal_texture = device.new_texture(&texture_descriptor);
-    Some(metal_texture)
-}
-
 #[repr(C)]
 enum ShadowInputIndex {
    Vertices = 0,
@@ -1162,10 +1255,9 @@ enum SurfaceInputIndex {
 }

 #[repr(C)]
-enum PathInputIndex {
+enum PathRasterizationInputIndex {
    Vertices = 0,
-    ViewportSize = 1,
-    Sprites = 2,
+    AtlasTextureSize = 1,
 }

 #[derive(Clone, Debug, Eq, PartialEq)]
@@ -1173,6 +1265,7 @@ enum PathInputIndex {
 pub struct PathSprite {
    pub bounds: Bounds<ScaledPixels>,
    pub color: Background,
+    pub tile: AtlasTile,
 }

 #[derive(Clone, Debug, Eq, PartialEq)]
--- a/crates/gpui/src/platform/mac/shaders.metal
+++ b/crates/gpui/src/platform/mac/shaders.metal
@@ -698,27 +698,76 @@ fragment float4 polychrome_sprite_fragment(
  return color;
 }

-struct PathVertexOutput {
+struct PathRasterizationVertexOutput {
  float4 position [[position]];
+  float2 st_position;
+  float clip_rect_distance [[clip_distance]][4];
+};
+
+struct PathRasterizationFragmentInput {
+  float4 position [[position]];
+  float2 st_position;
+};
+
+vertex PathRasterizationVertexOutput path_rasterization_vertex(
+    uint vertex_id [[vertex_id]],
+    constant PathVertex_ScaledPixels *vertices
+    [[buffer(PathRasterizationInputIndex_Vertices)]],
+    constant Size_DevicePixels *atlas_size
+    [[buffer(PathRasterizationInputIndex_AtlasTextureSize)]]) {
+  PathVertex_ScaledPixels v = vertices[vertex_id];
+  float2 vertex_position = float2(v.xy_position.x, v.xy_position.y);
+  float2 viewport_size = float2(atlas_size->width, atlas_size->height);
+  return PathRasterizationVertexOutput{
+      float4(vertex_position / viewport_size * float2(2., -2.) +
+                 float2(-1., 1.),
+             0., 1.),
+      float2(v.st_position.x, v.st_position.y),
+      {v.xy_position.x - v.content_mask.bounds.origin.x,
+       v.content_mask.bounds.origin.x + v.content_mask.bounds.size.width -
+           v.xy_position.x,
+       v.xy_position.y - v.content_mask.bounds.origin.y,
+       v.content_mask.bounds.origin.y + v.content_mask.bounds.size.height -
+           v.xy_position.y}};
+}
+
+fragment float4 path_rasterization_fragment(PathRasterizationFragmentInput input
+                                            [[stage_in]]) {
+  float2 dx = dfdx(input.st_position);
+  float2 dy = dfdy(input.st_position);
+  float2 gradient = float2((2. * input.st_position.x) * dx.x - dx.y,
+                           (2. * input.st_position.x) * dy.x - dy.y);
+  float f = (input.st_position.x * input.st_position.x) - input.st_position.y;
+  float distance = f / length(gradient);
+  float alpha = saturate(0.5 - distance);
+  return float4(alpha, 0., 0., 1.);
+}
+
+struct PathSpriteVertexOutput {
+  float4 position [[position]];
+  float2 tile_position;
  uint sprite_id [[flat]];
  float4 solid_color [[flat]];
  float4 color0 [[flat]];
  float4 color1 [[flat]];
-  float4 clip_distance;
 };

-vertex PathVertexOutput path_vertex(
-    uint vertex_id [[vertex_id]],
-    constant PathVertex_ScaledPixels *vertices [[buffer(PathInputIndex_Vertices)]],
-    uint sprite_id [[instance_id]],
-    constant PathSprite *sprites [[buffer(PathInputIndex_Sprites)]],
-    constant Size_DevicePixels *input_viewport_size [[buffer(PathInputIndex_ViewportSize)]]) {
-  PathVertex_ScaledPixels v = vertices[vertex_id];
-  float2 vertex_position = float2(v.xy_position.x, v.xy_position.y);
-  float2 viewport_size = float2((float)input_viewport_size->width,
-                                (float)input_viewport_size->height);
+vertex PathSpriteVertexOutput path_sprite_vertex(
+    uint unit_vertex_id [[vertex_id]], uint sprite_id [[instance_id]],
+    constant float2 *unit_vertices [[buffer(SpriteInputIndex_Vertices)]],
+    constant PathSprite *sprites [[buffer(SpriteInputIndex_Sprites)]],
+    constant Size_DevicePixels *viewport_size
+    [[buffer(SpriteInputIndex_ViewportSize)]],
+    constant Size_DevicePixels *atlas_size
+    [[buffer(SpriteInputIndex_AtlasTextureSize)]]) {
+
+  float2 unit_vertex = unit_vertices[unit_vertex_id];
  PathSprite sprite = sprites[sprite_id];
-  float4 device_position = float4(vertex_position / viewport_size * float2(2., -2.) + float2(-1., 1.), 0., 1.);
+  // Don't apply content mask because it was already accounted for when
+  // rasterizing the path.
+  float4 device_position =
+      to_device_position(unit_vertex, sprite.bounds, viewport_size);
+  float2 tile_position = to_tile_position(unit_vertex, sprite.tile, atlas_size);

  GradientColor gradient = prepare_fill_color(
    sprite.color.tag,
@@ -728,32 +777,30 @@ vertex PathVertexOutput path_vertex(
    sprite.color.colors[1].color
  );

-  return PathVertexOutput{
+  return PathSpriteVertexOutput{
    device_position,
+    tile_position,
    sprite_id,
    gradient.solid,
    gradient.color0,
-    gradient.color1,
-    {v.xy_position.x - v.content_mask.bounds.origin.x,
-       v.content_mask.bounds.origin.x + v.content_mask.bounds.size.width -
-           v.xy_position.x,
-       v.xy_position.y - v.content_mask.bounds.origin.y,
-       v.content_mask.bounds.origin.y + v.content_mask.bounds.size.height -
-           v.xy_position.y}
+    gradient.color1
  };
 }

-fragment float4 path_fragment(
-    PathVertexOutput input [[stage_in]],
-    constant PathSprite *sprites [[buffer(PathInputIndex_Sprites)]]) {
-  if (any(input.clip_distance < float4(0.0))) {
-    return float4(0.0);
-  }
-
+fragment float4 path_sprite_fragment(
+    PathSpriteVertexOutput input [[stage_in]],
+    constant PathSprite *sprites [[buffer(SpriteInputIndex_Sprites)]],
+    texture2d<float> atlas_texture [[texture(SpriteInputIndex_AtlasTexture)]]) {
+  constexpr sampler atlas_texture_sampler(mag_filter::linear,
+                                          min_filter::linear);
+  float4 sample =
+      atlas_texture.sample(atlas_texture_sampler, input.tile_position);
+  float mask = 1. - abs(1. - fmod(sample.r, 2.));
  PathSprite sprite = sprites[input.sprite_id];
  Background background = sprite.color;
  float4 color = fill_color(background, input.position.xy, sprite.bounds,
    input.solid_color, input.color0, input.color1);
+  color.a *= mask;
  return color;
 }

--- a/crates/gpui/src/platform/test/window.rs
+++ b/crates/gpui/src/platform/test/window.rs
@@ -341,7 +341,7 @@ impl PlatformAtlas for TestAtlas {
            crate::AtlasTile {
                texture_id: AtlasTextureId {
                    index: texture_id,
-                    kind: crate::AtlasTextureKind::Polychrome,
+                    kind: crate::AtlasTextureKind::Path,
                },
                tile_id: TileId(tile_id),
                padding: 0,
--- a/crates/gpui/src/scene.rs
+++ b/crates/gpui/src/scene.rs
@@ -6,7 +6,7 @@ use serde::{Deserialize, Serialize};

 use crate::{
    AtlasTextureId, AtlasTile, Background, Bounds, ContentMask, Corners, Edges, Hsla, Pixels,
-    Point, Radians, ScaledPixels, Size, bounds_tree::BoundsTree,
+    Point, Radians, ScaledPixels, Size, bounds_tree::BoundsTree, point,
 };
 use std::{fmt::Debug, iter::Peekable, ops::Range, slice};

@@ -43,7 +43,13 @@ impl Scene {
        self.surfaces.clear();
    }

-    #[allow(dead_code)]
+    #[cfg_attr(
+        all(
+            any(target_os = "linux", target_os = "freebsd"),
+            not(any(feature = "x11", feature = "wayland"))
+        ),
+        allow(dead_code)
+    )]
    pub fn paths(&self) -> &[Path<ScaledPixels>] {
        &self.paths
    }
@@ -683,7 +689,6 @@ pub struct Path<P: Clone + Debug + Default + PartialEq> {
    start: Point<P>,
    current: Point<P>,
    contour_count: usize,
-    base_scale: f32,
 }

 impl Path<Pixels> {
@@ -702,35 +707,25 @@ impl Path<Pixels> {
            content_mask: Default::default(),
            color: Default::default(),
            contour_count: 0,
-            base_scale: 1.0,
        }
    }

-    /// Set the base scale of the path.
-    pub fn scale(mut self, factor: f32) -> Self {
-        self.base_scale = factor;
-        self
-    }
-
-    /// Apply a scale to the path.
-    pub(crate) fn apply_scale(&self, factor: f32) -> Path<ScaledPixels> {
+    /// Scale this path by the given factor.
+    pub fn scale(&self, factor: f32) -> Path<ScaledPixels> {
        Path {
            id: self.id,
            order: self.order,
-            bounds: self.bounds.scale(self.base_scale * factor),
-            content_mask: self.content_mask.scale(self.base_scale * factor),
+            bounds: self.bounds.scale(factor),
+            content_mask: self.content_mask.scale(factor),
            vertices: self
                .vertices
                .iter()
-                .map(|vertex| vertex.scale(self.base_scale * factor))
+                .map(|vertex| vertex.scale(factor))
                .collect(),
-            start: self
-                .start
-                .map(|start| start.scale(self.base_scale * factor)),
-            current: self.current.scale(self.base_scale * factor),
+            start: self.start.map(|start| start.scale(factor)),
+            current: self.current.scale(factor),
            contour_count: self.contour_count,
            color: self.color,
-            base_scale: 1.0,
        }
    }

@@ -745,7 +740,10 @@ impl Path<Pixels> {
    pub fn line_to(&mut self, to: Point<Pixels>) {
        self.contour_count += 1;
        if self.contour_count > 1 {
-            self.push_triangle((self.start, self.current, to));
+            self.push_triangle(
+                (self.start, self.current, to),
+                (point(0., 1.), point(0., 1.), point(0., 1.)),
+            );
        }
        self.current = to;
    }
@@ -754,15 +752,25 @@ impl Path<Pixels> {
    pub fn curve_to(&mut self, to: Point<Pixels>, ctrl: Point<Pixels>) {
        self.contour_count += 1;
        if self.contour_count > 1 {
-            self.push_triangle((self.start, self.current, to));
+            self.push_triangle(
+                (self.start, self.current, to),
+                (point(0., 1.), point(0., 1.), point(0., 1.)),
+            );
        }

-        self.push_triangle((self.current, ctrl, to));
+        self.push_triangle(
+            (self.current, ctrl, to),
+            (point(0., 0.), point(0.5, 0.), point(1., 1.)),
+        );
        self.current = to;
    }

    /// Push a triangle to the Path.
-    pub fn push_triangle(&mut self, xy: (Point<Pixels>, Point<Pixels>, Point<Pixels>)) {
+    pub fn push_triangle(
+        &mut self,
+        xy: (Point<Pixels>, Point<Pixels>, Point<Pixels>),
+        st: (Point<f32>, Point<f32>, Point<f32>),
+    ) {
        self.bounds = self
            .bounds
            .union(&Bounds {
@@ -780,14 +788,17 @@ impl Path<Pixels> {

        self.vertices.push(PathVertex {
            xy_position: xy.0,
+            st_position: st.0,
            content_mask: Default::default(),
        });
        self.vertices.push(PathVertex {
            xy_position: xy.1,
+            st_position: st.1,
            content_mask: Default::default(),
        });
        self.vertices.push(PathVertex {
            xy_position: xy.2,
+            st_position: st.2,
            content_mask: Default::default(),
        });
    }
@@ -803,6 +814,7 @@ impl From<Path<ScaledPixels>> for Primitive {
 #[repr(C)]
 pub(crate) struct PathVertex<P: Clone + Debug + Default + PartialEq> {
    pub(crate) xy_position: Point<P>,
+    pub(crate) st_position: Point<f32>,
    pub(crate) content_mask: ContentMask<P>,
 }

@@ -810,6 +822,7 @@ impl PathVertex<Pixels> {
    pub fn scale(&self, factor: f32) -> PathVertex<ScaledPixels> {
        PathVertex {
            xy_position: self.xy_position.scale(factor),
+            st_position: self.st_position,
            content_mask: self.content_mask.scale(factor),
        }
    }
--- a/crates/gpui/src/window.rs
+++ b/crates/gpui/src/window.rs
@@ -2658,7 +2658,7 @@ impl Window {
        path.color = color.opacity(opacity);
        self.next_frame
            .scene
-            .insert_primitive(path.apply_scale(scale_factor));
+            .insert_primitive(path.scale(scale_factor));
    }

    /// Paint an underline into the scene for the next frame at the current z-index.
--- a/crates/icons/src/icons.rs
+++ b/crates/icons/src/icons.rs
@@ -21,6 +21,7 @@ pub enum IconName {
    AiOpenAi,
    AiOpenRouter,
    AiVZero,
+    AiXAi,
    AiZed,
    ArrowCircle,
    ArrowDown,
@@ -106,6 +107,7 @@ pub enum IconName {
    Ellipsis,
    EllipsisVertical,
    Envelope,
+    Equal,
    Eraser,
    Escape,
    Exit,
--- a/crates/language_model/src/language_model.rs
+++ b/crates/language_model/src/language_model.rs
@@ -116,6 +116,12 @@ pub enum LanguageModelCompletionError {
        provider: LanguageModelProviderName,
        message: String,
    },
+    #[error("{message}")]
+    UpstreamProviderError {
+        message: String,
+        status: StatusCode,
+        retry_after: Option<Duration>,
+    },
    #[error("HTTP response error from {provider}'s API: status {status_code} - {message:?}")]
    HttpResponseError {
        provider: LanguageModelProviderName,
--- a/crates/language_models/Cargo.toml
+++ b/crates/language_models/Cargo.toml
@@ -43,6 +43,7 @@ ollama = { workspace = true, features = ["schemars"] }
 open_ai = { workspace = true, features = ["schemars"] }
 open_router = { workspace = true, features = ["schemars"] }
 vercel = { workspace = true, features = ["schemars"] }
+x_ai = { workspace = true, features = ["schemars"] }
 partial-json-fixer.workspace = true
 proto.workspace = true
 release_channel.workspace = true
--- a/crates/language_models/src/language_models.rs
+++ b/crates/language_models/src/language_models.rs
@@ -20,6 +20,7 @@ use crate::provider::ollama::OllamaLanguageModelProvider;
 use crate::provider::open_ai::OpenAiLanguageModelProvider;
 use crate::provider::open_router::OpenRouterLanguageModelProvider;
 use crate::provider::vercel::VercelLanguageModelProvider;
+use crate::provider::x_ai::XAiLanguageModelProvider;
 pub use crate::settings::*;

 pub fn init(user_store: Entity<UserStore>, client: Arc<Client>, cx: &mut App) {
@@ -81,5 +82,6 @@ fn register_language_model_providers(
        VercelLanguageModelProvider::new(client.http_client(), cx),
        cx,
    );
+    registry.register_provider(XAiLanguageModelProvider::new(client.http_client(), cx), cx);
    registry.register_provider(CopilotChatLanguageModelProvider::new(cx), cx);
 }
--- a/crates/language_models/src/provider.rs
+++ b/crates/language_models/src/provider.rs
@@ -10,3 +10,4 @@ pub mod ollama;
 pub mod open_ai;
 pub mod open_router;
 pub mod vercel;
+pub mod x_ai;
--- a/crates/language_models/src/provider/cloud.rs
+++ b/crates/language_models/src/provider/cloud.rs
@@ -644,8 +644,62 @@ struct ApiError {
    headers: HeaderMap<HeaderValue>,
 }

+/// Represents error responses from Zed's cloud API.
+///
+/// Example JSON for an upstream HTTP error:
+/// ```json
+/// {
+///   "code": "upstream_http_error",
+///   "message": "Received an error from the Anthropic API: upstream connect error or disconnect/reset before headers, reset reason: connection timeout",
+///   "upstream_status": 503
+/// }
+/// ```
+#[derive(Debug, serde::Deserialize)]
+struct CloudApiError {
+    code: String,
+    message: String,
+    #[serde(default)]
+    #[serde(deserialize_with = "deserialize_optional_status_code")]
+    upstream_status: Option<StatusCode>,
+    #[serde(default)]
+    retry_after: Option<f64>,
+}
+
+fn deserialize_optional_status_code<'de, D>(deserializer: D) -> Result<Option<StatusCode>, D::Error>
+where
+    D: serde::Deserializer<'de>,
+{
+    let opt: Option<u16> = Option::deserialize(deserializer)?;
+    Ok(opt.and_then(|code| StatusCode::from_u16(code).ok()))
+}
+
 impl From<ApiError> for LanguageModelCompletionError {
    fn from(error: ApiError) -> Self {
+        if let Ok(cloud_error) = serde_json::from_str::<CloudApiError>(&error.body) {
+            if cloud_error.code.starts_with("upstream_http_") {
+                let status = if let Some(status) = cloud_error.upstream_status {
+                    status
+                } else if cloud_error.code.ends_with("_error") {
+                    error.status
+                } else {
+                    // If there's a status code in the code string (e.g. "upstream_http_429")
+                    // then use that; otherwise, see if the JSON contains a status code.
+                    cloud_error
+                        .code
+                        .strip_prefix("upstream_http_")
+                        .and_then(|code_str| code_str.parse::<u16>().ok())
+                        .and_then(|code| StatusCode::from_u16(code).ok())
+                        .unwrap_or(error.status)
+                };
+
+                return LanguageModelCompletionError::UpstreamProviderError {
+                    message: cloud_error.message,
+                    status,
+                    retry_after: cloud_error.retry_after.map(Duration::from_secs_f64),
+                };
+            }
+        }
+
        let retry_after = None;
        LanguageModelCompletionError::from_http_status(
            PROVIDER_NAME,
@@ -1279,3 +1333,155 @@ impl Component for ZedAiConfiguration {
        )
    }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use http_client::http::{HeaderMap, StatusCode};
+    use language_model::LanguageModelCompletionError;
+
+    #[test]
+    fn test_api_error_conversion_with_upstream_http_error() {
+        // upstream_http_error with 503 status should become ServerOverloaded
+        let error_body = r#"{"code":"upstream_http_error","message":"Received an error from the Anthropic API: upstream connect error or disconnect/reset before headers, reset reason: connection timeout","upstream_status":503}"#;
+
+        let api_error = ApiError {
+            status: StatusCode::INTERNAL_SERVER_ERROR,
+            body: error_body.to_string(),
+            headers: HeaderMap::new(),
+        };
+
+        let completion_error: LanguageModelCompletionError = api_error.into();
+
+        match completion_error {
+            LanguageModelCompletionError::UpstreamProviderError { message, .. } => {
+                assert_eq!(
+                    message,
+                    "Received an error from the Anthropic API: upstream connect error or disconnect/reset before headers, reset reason: connection timeout"
+                );
+            }
+            _ => panic!(
+                "Expected UpstreamProviderError for upstream 503, got: {:?}",
+                completion_error
+            ),
+        }
+
+        // upstream_http_error with 500 status should become ApiInternalServerError
+        let error_body = r#"{"code":"upstream_http_error","message":"Received an error from the OpenAI API: internal server error","upstream_status":500}"#;
+
+        let api_error = ApiError {
+            status: StatusCode::INTERNAL_SERVER_ERROR,
+            body: error_body.to_string(),
+            headers: HeaderMap::new(),
+        };
+
+        let completion_error: LanguageModelCompletionError = api_error.into();
+
+        match completion_error {
+            LanguageModelCompletionError::UpstreamProviderError { message, .. } => {
+                assert_eq!(
+                    message,
+                    "Received an error from the OpenAI API: internal server error"
+                );
+            }
+            _ => panic!(
+                "Expected UpstreamProviderError for upstream 500, got: {:?}",
+                completion_error
+            ),
+        }
+
+        // upstream_http_error with 429 status should become RateLimitExceeded
+        let error_body = r#"{"code":"upstream_http_error","message":"Received an error from the Google API: rate limit exceeded","upstream_status":429}"#;
+
+        let api_error = ApiError {
+            status: StatusCode::INTERNAL_SERVER_ERROR,
+            body: error_body.to_string(),
+            headers: HeaderMap::new(),
+        };
+
+        let completion_error: LanguageModelCompletionError = api_error.into();
+
+        match completion_error {
+            LanguageModelCompletionError::UpstreamProviderError { message, .. } => {
+                assert_eq!(
+                    message,
+                    "Received an error from the Google API: rate limit exceeded"
+                );
+            }
+            _ => panic!(
+                "Expected UpstreamProviderError for upstream 429, got: {:?}",
+                completion_error
+            ),
+        }
+
+        // Regular 500 error without upstream_http_error should remain ApiInternalServerError for Zed
+        let error_body = "Regular internal server error";
+
+        let api_error = ApiError {
+            status: StatusCode::INTERNAL_SERVER_ERROR,
+            body: error_body.to_string(),
+            headers: HeaderMap::new(),
+        };
+
+        let completion_error: LanguageModelCompletionError = api_error.into();
+
+        match completion_error {
+            LanguageModelCompletionError::ApiInternalServerError { provider, message } => {
+                assert_eq!(provider, PROVIDER_NAME);
+                assert_eq!(message, "Regular internal server error");
+            }
+            _ => panic!(
+                "Expected ApiInternalServerError for regular 500, got: {:?}",
+                completion_error
+            ),
+        }
+
+        // upstream_http_429 format should be converted to UpstreamProviderError
+        let error_body = r#"{"code":"upstream_http_429","message":"Upstream Anthropic rate limit exceeded.","retry_after":30.5}"#;
+
+        let api_error = ApiError {
+            status: StatusCode::INTERNAL_SERVER_ERROR,
+            body: error_body.to_string(),
+            headers: HeaderMap::new(),
+        };
+
+        let completion_error: LanguageModelCompletionError = api_error.into();
+
+        match completion_error {
+            LanguageModelCompletionError::UpstreamProviderError {
+                message,
+                status,
+                retry_after,
+            } => {
+                assert_eq!(message, "Upstream Anthropic rate limit exceeded.");
+                assert_eq!(status, StatusCode::TOO_MANY_REQUESTS);
+                assert_eq!(retry_after, Some(Duration::from_secs_f64(30.5)));
+            }
+            _ => panic!(
+                "Expected UpstreamProviderError for upstream_http_429, got: {:?}",
+                completion_error
+            ),
+        }
+
+        // Invalid JSON in error body should fall back to regular error handling
+        let error_body = "Not JSON at all";
+
+        let api_error = ApiError {
+            status: StatusCode::INTERNAL_SERVER_ERROR,
+            body: error_body.to_string(),
+            headers: HeaderMap::new(),
+        };
+
+        let completion_error: LanguageModelCompletionError = api_error.into();
+
+        match completion_error {
+            LanguageModelCompletionError::ApiInternalServerError { provider, .. } => {
+                assert_eq!(provider, PROVIDER_NAME);
+            }
+            _ => panic!(
+                "Expected ApiInternalServerError for invalid JSON, got: {:?}",
+                completion_error
+            ),
+        }
+    }
+}
--- a/crates/language_models/src/provider/open_router.rs
+++ b/crates/language_models/src/provider/open_router.rs
@@ -376,7 +376,7 @@ impl LanguageModel for OpenRouterLanguageModel {

    fn tool_input_format(&self) -> LanguageModelToolSchemaFormat {
        let model_id = self.model.id().trim().to_lowercase();
-        if model_id.contains("gemini") {
+        if model_id.contains("gemini") || model_id.contains("grok-4") {
            LanguageModelToolSchemaFormat::JsonSchemaSubset
        } else {
            LanguageModelToolSchemaFormat::JsonSchema
--- a/crates/language_models/src/provider/x_ai.rs
+++ b/crates/language_models/src/provider/x_ai.rs
@@ -0,0 +1,571 @@
+use anyhow::{Context as _, Result, anyhow};
+use collections::BTreeMap;
+use credentials_provider::CredentialsProvider;
+use futures::{FutureExt, StreamExt, future::BoxFuture};
+use gpui::{AnyView, App, AsyncApp, Context, Entity, Subscription, Task, Window};
+use http_client::HttpClient;
+use language_model::{
+    AuthenticateError, LanguageModel, LanguageModelCompletionError, LanguageModelCompletionEvent,
+    LanguageModelId, LanguageModelName, LanguageModelProvider, LanguageModelProviderId,
+    LanguageModelProviderName, LanguageModelProviderState, LanguageModelRequest,
+    LanguageModelToolChoice, LanguageModelToolSchemaFormat, RateLimiter, Role,
+};
+use menu;
+use open_ai::ResponseStreamEvent;
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+use settings::{Settings, SettingsStore};
+use std::sync::Arc;
+use strum::IntoEnumIterator;
+use x_ai::Model;
+
+use ui::{ElevationIndex, List, Tooltip, prelude::*};
+use ui_input::SingleLineInput;
+use util::ResultExt;
+
+use crate::{AllLanguageModelSettings, ui::InstructionListItem};
+
+const PROVIDER_ID: &str = "x_ai";
+const PROVIDER_NAME: &str = "xAI";
+
+#[derive(Default, Clone, Debug, PartialEq)]
+pub struct XAiSettings {
+    pub api_url: String,
+    pub available_models: Vec<AvailableModel>,
+}
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, JsonSchema)]
+pub struct AvailableModel {
+    pub name: String,
+    pub display_name: Option<String>,
+    pub max_tokens: u64,
+    pub max_output_tokens: Option<u64>,
+    pub max_completion_tokens: Option<u64>,
+}
+
+pub struct XAiLanguageModelProvider {
+    http_client: Arc<dyn HttpClient>,
+    state: gpui::Entity<State>,
+}
+
+pub struct State {
+    api_key: Option<String>,
+    api_key_from_env: bool,
+    _subscription: Subscription,
+}
+
+const XAI_API_KEY_VAR: &str = "XAI_API_KEY";
+
+impl State {
+    fn is_authenticated(&self) -> bool {
+        self.api_key.is_some()
+    }
+
+    fn reset_api_key(&self, cx: &mut Context<Self>) -> Task<Result<()>> {
+        let credentials_provider = <dyn CredentialsProvider>::global(cx);
+        let settings = &AllLanguageModelSettings::get_global(cx).x_ai;
+        let api_url = if settings.api_url.is_empty() {
+            x_ai::XAI_API_URL.to_string()
+        } else {
+            settings.api_url.clone()
+        };
+        cx.spawn(async move |this, cx| {
+            credentials_provider
+                .delete_credentials(&api_url, &cx)
+                .await
+                .log_err();
+            this.update(cx, |this, cx| {
+                this.api_key = None;
+                this.api_key_from_env = false;
+                cx.notify();
+            })
+        })
+    }
+
+    fn set_api_key(&mut self, api_key: String, cx: &mut Context<Self>) -> Task<Result<()>> {
+        let credentials_provider = <dyn CredentialsProvider>::global(cx);
+        let settings = &AllLanguageModelSettings::get_global(cx).x_ai;
+        let api_url = if settings.api_url.is_empty() {
+            x_ai::XAI_API_URL.to_string()
+        } else {
+            settings.api_url.clone()
+        };
+        cx.spawn(async move |this, cx| {
+            credentials_provider
+                .write_credentials(&api_url, "Bearer", api_key.as_bytes(), &cx)
+                .await
+                .log_err();
+            this.update(cx, |this, cx| {
+                this.api_key = Some(api_key);
+                cx.notify();
+            })
+        })
+    }
+
+    fn authenticate(&self, cx: &mut Context<Self>) -> Task<Result<(), AuthenticateError>> {
+        if self.is_authenticated() {
+            return Task::ready(Ok(()));
+        }
+
+        let credentials_provider = <dyn CredentialsProvider>::global(cx);
+        let settings = &AllLanguageModelSettings::get_global(cx).x_ai;
+        let api_url = if settings.api_url.is_empty() {
+            x_ai::XAI_API_URL.to_string()
+        } else {
+            settings.api_url.clone()
+        };
+        cx.spawn(async move |this, cx| {
+            let (api_key, from_env) = if let Ok(api_key) = std::env::var(XAI_API_KEY_VAR) {
+                (api_key, true)
+            } else {
+                let (_, api_key) = credentials_provider
+                    .read_credentials(&api_url, &cx)
+                    .await?
+                    .ok_or(AuthenticateError::CredentialsNotFound)?;
+                (
+                    String::from_utf8(api_key).context("invalid {PROVIDER_NAME} API key")?,
+                    false,
+                )
+            };
+            this.update(cx, |this, cx| {
+                this.api_key = Some(api_key);
+                this.api_key_from_env = from_env;
+                cx.notify();
+            })?;
+
+            Ok(())
+        })
+    }
+}
+
+impl XAiLanguageModelProvider {
+    pub fn new(http_client: Arc<dyn HttpClient>, cx: &mut App) -> Self {
+        let state = cx.new(|cx| State {
+            api_key: None,
+            api_key_from_env: false,
+            _subscription: cx.observe_global::<SettingsStore>(|_this: &mut State, cx| {
+                cx.notify();
+            }),
+        });
+
+        Self { http_client, state }
+    }
+
+    fn create_language_model(&self, model: x_ai::Model) -> Arc<dyn LanguageModel> {
+        Arc::new(XAiLanguageModel {
+            id: LanguageModelId::from(model.id().to_string()),
+            model,
+            state: self.state.clone(),
+            http_client: self.http_client.clone(),
+            request_limiter: RateLimiter::new(4),
+        })
+    }
+}
+
+impl LanguageModelProviderState for XAiLanguageModelProvider {
+    type ObservableEntity = State;
+
+    fn observable_entity(&self) -> Option<gpui::Entity<Self::ObservableEntity>> {
+        Some(self.state.clone())
+    }
+}
+
+impl LanguageModelProvider for XAiLanguageModelProvider {
+    fn id(&self) -> LanguageModelProviderId {
+        LanguageModelProviderId(PROVIDER_ID.into())
+    }
+
+    fn name(&self) -> LanguageModelProviderName {
+        LanguageModelProviderName(PROVIDER_NAME.into())
+    }
+
+    fn icon(&self) -> IconName {
+        IconName::AiXAi
+    }
+
+    fn default_model(&self, _cx: &App) -> Option<Arc<dyn LanguageModel>> {
+        Some(self.create_language_model(x_ai::Model::default()))
+    }
+
+    fn default_fast_model(&self, _cx: &App) -> Option<Arc<dyn LanguageModel>> {
+        Some(self.create_language_model(x_ai::Model::default_fast()))
+    }
+
+    fn provided_models(&self, cx: &App) -> Vec<Arc<dyn LanguageModel>> {
+        let mut models = BTreeMap::default();
+
+        for model in x_ai::Model::iter() {
+            if !matches!(model, x_ai::Model::Custom { .. }) {
+                models.insert(model.id().to_string(), model);
+            }
+        }
+
+        for model in &AllLanguageModelSettings::get_global(cx)
+            .x_ai
+            .available_models
+        {
+            models.insert(
+                model.name.clone(),
+                x_ai::Model::Custom {
+                    name: model.name.clone(),
+                    display_name: model.display_name.clone(),
+                    max_tokens: model.max_tokens,
+                    max_output_tokens: model.max_output_tokens,
+                    max_completion_tokens: model.max_completion_tokens,
+                },
+            );
+        }
+
+        models
+            .into_values()
+            .map(|model| self.create_language_model(model))
+            .collect()
+    }
+
+    fn is_authenticated(&self, cx: &App) -> bool {
+        self.state.read(cx).is_authenticated()
+    }
+
+    fn authenticate(&self, cx: &mut App) -> Task<Result<(), AuthenticateError>> {
+        self.state.update(cx, |state, cx| state.authenticate(cx))
+    }
+
+    fn configuration_view(&self, window: &mut Window, cx: &mut App) -> AnyView {
+        cx.new(|cx| ConfigurationView::new(self.state.clone(), window, cx))
+            .into()
+    }
+
+    fn reset_credentials(&self, cx: &mut App) -> Task<Result<()>> {
+        self.state.update(cx, |state, cx| state.reset_api_key(cx))
+    }
+}
+
+pub struct XAiLanguageModel {
+    id: LanguageModelId,
+    model: x_ai::Model,
+    state: gpui::Entity<State>,
+    http_client: Arc<dyn HttpClient>,
+    request_limiter: RateLimiter,
+}
+
+impl XAiLanguageModel {
+    fn stream_completion(
+        &self,
+        request: open_ai::Request,
+        cx: &AsyncApp,
+    ) -> BoxFuture<'static, Result<futures::stream::BoxStream<'static, Result<ResponseStreamEvent>>>>
+    {
+        let http_client = self.http_client.clone();
+        let Ok((api_key, api_url)) = cx.read_entity(&self.state, |state, cx| {
+            let settings = &AllLanguageModelSettings::get_global(cx).x_ai;
+            let api_url = if settings.api_url.is_empty() {
+                x_ai::XAI_API_URL.to_string()
+            } else {
+                settings.api_url.clone()
+            };
+            (state.api_key.clone(), api_url)
+        }) else {
+            return futures::future::ready(Err(anyhow!("App state dropped"))).boxed();
+        };
+
+        let future = self.request_limiter.stream(async move {
+            let api_key = api_key.context("Missing xAI API Key")?;
+            let request =
+                open_ai::stream_completion(http_client.as_ref(), &api_url, &api_key, request);
+            let response = request.await?;
+            Ok(response)
+        });
+
+        async move { Ok(future.await?.boxed()) }.boxed()
+    }
+}
+
+impl LanguageModel for XAiLanguageModel {
+    fn id(&self) -> LanguageModelId {
+        self.id.clone()
+    }
+
+    fn name(&self) -> LanguageModelName {
+        LanguageModelName::from(self.model.display_name().to_string())
+    }
+
+    fn provider_id(&self) -> LanguageModelProviderId {
+        LanguageModelProviderId(PROVIDER_ID.into())
+    }
+
+    fn provider_name(&self) -> LanguageModelProviderName {
+        LanguageModelProviderName(PROVIDER_NAME.into())
+    }
+
+    fn supports_tools(&self) -> bool {
+        self.model.supports_tool()
+    }
+
+    fn supports_images(&self) -> bool {
+        self.model.supports_images()
+    }
+
+    fn supports_tool_choice(&self, choice: LanguageModelToolChoice) -> bool {
+        match choice {
+            LanguageModelToolChoice::Auto
+            | LanguageModelToolChoice::Any
+            | LanguageModelToolChoice::None => true,
+        }
+    }
+    fn tool_input_format(&self) -> LanguageModelToolSchemaFormat {
+        let model_id = self.model.id().trim().to_lowercase();
+        if model_id.eq(x_ai::Model::Grok4.id()) {
+            LanguageModelToolSchemaFormat::JsonSchemaSubset
+        } else {
+            LanguageModelToolSchemaFormat::JsonSchema
+        }
+    }
+
+    fn telemetry_id(&self) -> String {
+        format!("x_ai/{}", self.model.id())
+    }
+
+    fn max_token_count(&self) -> u64 {
+        self.model.max_token_count()
+    }
+
+    fn max_output_tokens(&self) -> Option<u64> {
+        self.model.max_output_tokens()
+    }
+
+    fn count_tokens(
+        &self,
+        request: LanguageModelRequest,
+        cx: &App,
+    ) -> BoxFuture<'static, Result<u64>> {
+        count_xai_tokens(request, self.model.clone(), cx)
+    }
+
+    fn stream_completion(
+        &self,
+        request: LanguageModelRequest,
+        cx: &AsyncApp,
+    ) -> BoxFuture<
+        'static,
+        Result<
+            futures::stream::BoxStream<
+                'static,
+                Result<LanguageModelCompletionEvent, LanguageModelCompletionError>,
+            >,
+            LanguageModelCompletionError,
+        >,
+    > {
+        let request = crate::provider::open_ai::into_open_ai(
+            request,
+            self.model.id(),
+            self.model.supports_parallel_tool_calls(),
+            self.max_output_tokens(),
+        );
+        let completions = self.stream_completion(request, cx);
+        async move {
+            let mapper = crate::provider::open_ai::OpenAiEventMapper::new();
+            Ok(mapper.map_stream(completions.await?).boxed())
+        }
+        .boxed()
+    }
+}
+
+pub fn count_xai_tokens(
+    request: LanguageModelRequest,
+    model: Model,
+    cx: &App,
+) -> BoxFuture<'static, Result<u64>> {
+    cx.background_spawn(async move {
+        let messages = request
+            .messages
+            .into_iter()
+            .map(|message| tiktoken_rs::ChatCompletionRequestMessage {
+                role: match message.role {
+                    Role::User => "user".into(),
+                    Role::Assistant => "assistant".into(),
+                    Role::System => "system".into(),
+                },
+                content: Some(message.string_contents()),
+                name: None,
+                function_call: None,
+            })
+            .collect::<Vec<_>>();
+
+        let model_name = if model.max_token_count() >= 100_000 {
+            "gpt-4o"
+        } else {
+            "gpt-4"
+        };
+        tiktoken_rs::num_tokens_from_messages(model_name, &messages).map(|tokens| tokens as u64)
+    })
+    .boxed()
+}
+
+struct ConfigurationView {
+    api_key_editor: Entity<SingleLineInput>,
+    state: gpui::Entity<State>,
+    load_credentials_task: Option<Task<()>>,
+}
+
+impl ConfigurationView {
+    fn new(state: gpui::Entity<State>, window: &mut Window, cx: &mut Context<Self>) -> Self {
+        let api_key_editor = cx.new(|cx| {
+            SingleLineInput::new(
+                window,
+                cx,
+                "xai-0000000000000000000000000000000000000000000000000",
+            )
+            .label("API key")
+        });
+
+        cx.observe(&state, |_, _, cx| {
+            cx.notify();
+        })
+        .detach();
+
+        let load_credentials_task = Some(cx.spawn_in(window, {
+            let state = state.clone();
+            async move |this, cx| {
+                if let Some(task) = state
+                    .update(cx, |state, cx| state.authenticate(cx))
+                    .log_err()
+                {
+                    // We don't log an error, because "not signed in" is also an error.
+                    let _ = task.await;
+                }
+                this.update(cx, |this, cx| {
+                    this.load_credentials_task = None;
+                    cx.notify();
+                })
+                .log_err();
+            }
+        }));
+
+        Self {
+            api_key_editor,
+            state,
+            load_credentials_task,
+        }
+    }
+
+    fn save_api_key(&mut self, _: &menu::Confirm, window: &mut Window, cx: &mut Context<Self>) {
+        let api_key = self
+            .api_key_editor
+            .read(cx)
+            .editor()
+            .read(cx)
+            .text(cx)
+            .trim()
+            .to_string();
+
+        // Don't proceed if no API key is provided and we're not authenticated
+        if api_key.is_empty() && !self.state.read(cx).is_authenticated() {
+            return;
+        }
+
+        let state = self.state.clone();
+        cx.spawn_in(window, async move |_, cx| {
+            state
+                .update(cx, |state, cx| state.set_api_key(api_key, cx))?
+                .await
+        })
+        .detach_and_log_err(cx);
+
+        cx.notify();
+    }
+
+    fn reset_api_key(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        self.api_key_editor.update(cx, |input, cx| {
+            input.editor.update(cx, |editor, cx| {
+                editor.set_text("", window, cx);
+            });
+        });
+
+        let state = self.state.clone();
+        cx.spawn_in(window, async move |_, cx| {
+            state.update(cx, |state, cx| state.reset_api_key(cx))?.await
+        })
+        .detach_and_log_err(cx);
+
+        cx.notify();
+    }
+
+    fn should_render_editor(&self, cx: &mut Context<Self>) -> bool {
+        !self.state.read(cx).is_authenticated()
+    }
+}
+
+impl Render for ConfigurationView {
+    fn render(&mut self, _: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        let env_var_set = self.state.read(cx).api_key_from_env;
+
+        let api_key_section = if self.should_render_editor(cx) {
+            v_flex()
+                .on_action(cx.listener(Self::save_api_key))
+                .child(Label::new("To use Zed's agent with xAI, you need to add an API key. Follow these steps:"))
+                .child(
+                    List::new()
+                        .child(InstructionListItem::new(
+                            "Create one by visiting",
+                            Some("xAI console"),
+                            Some("https://console.x.ai/team/default/api-keys"),
+                        ))
+                        .child(InstructionListItem::text_only(
+                            "Paste your API key below and hit enter to start using the agent",
+                        )),
+                )
+                .child(self.api_key_editor.clone())
+                .child(
+                    Label::new(format!(
+                        "You can also assign the {XAI_API_KEY_VAR} environment variable and restart Zed."
+                    ))
+                    .size(LabelSize::Small)
+                    .color(Color::Muted),
+                )
+                .child(
+                    Label::new("Note that xAI is a custom OpenAI-compatible provider.")
+                        .size(LabelSize::Small)
+                        .color(Color::Muted),
+                )
+                .into_any()
+        } else {
+            h_flex()
+                .mt_1()
+                .p_1()
+                .justify_between()
+                .rounded_md()
+                .border_1()
+                .border_color(cx.theme().colors().border)
+                .bg(cx.theme().colors().background)
+                .child(
+                    h_flex()
+                        .gap_1()
+                        .child(Icon::new(IconName::Check).color(Color::Success))
+                        .child(Label::new(if env_var_set {
+                            format!("API key set in {XAI_API_KEY_VAR} environment variable.")
+                        } else {
+                            "API key configured.".to_string()
+                        })),
+                )
+                .child(
+                    Button::new("reset-api-key", "Reset API Key")
+                        .label_size(LabelSize::Small)
+                        .icon(IconName::Undo)
+                        .icon_size(IconSize::Small)
+                        .icon_position(IconPosition::Start)
+                        .layer(ElevationIndex::ModalSurface)
+                        .when(env_var_set, |this| {
+                            this.tooltip(Tooltip::text(format!("To reset your API key, unset the {XAI_API_KEY_VAR} environment variable.")))
+                        })
+                        .on_click(cx.listener(|this, _, window, cx| this.reset_api_key(window, cx))),
+                )
+                .into_any()
+        };
+
+        if self.load_credentials_task.is_some() {
+            div().child(Label::new("Loading credentials…")).into_any()
+        } else {
+            v_flex().size_full().child(api_key_section).into_any()
+        }
+    }
+}
--- a/crates/language_models/src/settings.rs
+++ b/crates/language_models/src/settings.rs
@@ -17,6 +17,7 @@ use crate::provider::{
    open_ai::OpenAiSettings,
    open_router::OpenRouterSettings,
    vercel::VercelSettings,
+    x_ai::XAiSettings,
 };

 /// Initializes the language model settings.
@@ -28,33 +29,33 @@ pub fn init(cx: &mut App) {
 pub struct AllLanguageModelSettings {
    pub anthropic: AnthropicSettings,
    pub bedrock: AmazonBedrockSettings,
-    pub ollama: OllamaSettings,
-    pub openai: OpenAiSettings,
-    pub open_router: OpenRouterSettings,
-    pub zed_dot_dev: ZedDotDevSettings,
-    pub google: GoogleSettings,
-    pub vercel: VercelSettings,
-
-    pub lmstudio: LmStudioSettings,
    pub deepseek: DeepSeekSettings,
+    pub google: GoogleSettings,
+    pub lmstudio: LmStudioSettings,
    pub mistral: MistralSettings,
+    pub ollama: OllamaSettings,
+    pub open_router: OpenRouterSettings,
+    pub openai: OpenAiSettings,
+    pub vercel: VercelSettings,
+    pub x_ai: XAiSettings,
+    pub zed_dot_dev: ZedDotDevSettings,
 }

 #[derive(Default, Clone, Debug, Serialize, Deserialize, PartialEq, JsonSchema)]
 pub struct AllLanguageModelSettingsContent {
    pub anthropic: Option<AnthropicSettingsContent>,
    pub bedrock: Option<AmazonBedrockSettingsContent>,
-    pub ollama: Option<OllamaSettingsContent>,
+    pub deepseek: Option<DeepseekSettingsContent>,
+    pub google: Option<GoogleSettingsContent>,
    pub lmstudio: Option<LmStudioSettingsContent>,
-    pub openai: Option<OpenAiSettingsContent>,
+    pub mistral: Option<MistralSettingsContent>,
+    pub ollama: Option<OllamaSettingsContent>,
    pub open_router: Option<OpenRouterSettingsContent>,
+    pub openai: Option<OpenAiSettingsContent>,
+    pub vercel: Option<VercelSettingsContent>,
+    pub x_ai: Option<XAiSettingsContent>,
    #[serde(rename = "zed.dev")]
    pub zed_dot_dev: Option<ZedDotDevSettingsContent>,
-    pub google: Option<GoogleSettingsContent>,
-    pub deepseek: Option<DeepseekSettingsContent>,
-    pub vercel: Option<VercelSettingsContent>,
-
-    pub mistral: Option<MistralSettingsContent>,
 }

 #[derive(Clone, Debug, Serialize, Deserialize, PartialEq, JsonSchema)]
@@ -114,6 +115,12 @@ pub struct GoogleSettingsContent {
    pub available_models: Option<Vec<provider::google::AvailableModel>>,
 }

+#[derive(Default, Clone, Debug, Serialize, Deserialize, PartialEq, JsonSchema)]
+pub struct XAiSettingsContent {
+    pub api_url: Option<String>,
+    pub available_models: Option<Vec<provider::x_ai::AvailableModel>>,
+}
+
 #[derive(Default, Clone, Debug, Serialize, Deserialize, PartialEq, JsonSchema)]
 pub struct ZedDotDevSettingsContent {
    available_models: Option<Vec<cloud::AvailableModel>>,
@@ -230,6 +237,18 @@ impl settings::Settings for AllLanguageModelSettings {
                vercel.as_ref().and_then(|s| s.available_models.clone()),
            );

+            // XAI
+            let x_ai = value.x_ai.clone();
+            merge(
+                &mut settings.x_ai.api_url,
+                x_ai.as_ref().and_then(|s| s.api_url.clone()),
+            );
+            merge(
+                &mut settings.x_ai.available_models,
+                x_ai.as_ref().and_then(|s| s.available_models.clone()),
+            );
+
+            // ZedDotDev
            merge(
                &mut settings.zed_dot_dev.available_models,
                value
--- a/crates/languages/src/lib.rs
+++ b/crates/languages/src/lib.rs
@@ -212,6 +212,10 @@ pub fn init(languages: Arc<LanguageRegistry>, node: NodeRuntime, cx: &mut App) {
            name: "gitcommit",
            ..Default::default()
        },
+        LanguageInfo {
+            name: "zed-keybind-context",
+            ..Default::default()
+        },
    ];

    for registration in built_in_languages {
--- a/crates/languages/src/zed-keybind-context/brackets.scm
+++ b/crates/languages/src/zed-keybind-context/brackets.scm
@@ -0,0 +1 @@
+("(" @open ")" @close)
--- a/crates/languages/src/zed-keybind-context/config.toml
+++ b/crates/languages/src/zed-keybind-context/config.toml
@@ -0,0 +1,6 @@
+name = "Zed Keybind Context"
+grammar = "rust"
+autoclose_before = ")"
+brackets = [
+    { start = "(", end = ")", close = true, newline = false },
+]
--- a/crates/languages/src/zed-keybind-context/highlights.scm
+++ b/crates/languages/src/zed-keybind-context/highlights.scm
@@ -0,0 +1,23 @@
+(identifier) @variable
+
+[
+  "("
+  ")"
+] @punctuation.bracket
+
+[
+  (integer_literal)
+  (float_literal)
+] @number
+
+(boolean_literal) @boolean
+
+[
+  "!="
+  "=="
+  "=>"
+  ">"
+  "&&"
+  "||"
+  "!"
+] @operator
--- a/crates/multi_buffer/src/multi_buffer.rs
+++ b/crates/multi_buffer/src/multi_buffer.rs
@@ -5905,7 +5905,6 @@ impl MultiBufferSnapshot {

            let depth = if found_indent {
                line_indent.len(tab_size) / tab_size
-                    + ((line_indent.len(tab_size) % tab_size) > 0) as u32
            } else {
                0
            };
--- a/crates/open_router/src/open_router.rs
+++ b/crates/open_router/src/open_router.rs
@@ -153,11 +153,12 @@ pub struct RequestUsage {
 }

 #[derive(Debug, Serialize, Deserialize)]
-#[serde(untagged)]
+#[serde(rename_all = "lowercase")]
 pub enum ToolChoice {
    Auto,
    Required,
    None,
+    #[serde(untagged)]
    Other(ToolDefinition),
 }

--- a/crates/project/src/debugger/session.rs
+++ b/crates/project/src/debugger/session.rs
@@ -1787,7 +1787,7 @@ impl Session {
        frame_id: Option<u64>,
        expression: String,
        cx: &mut Context<Self>,
-    ) -> Task<Option<String>> {
+    ) -> Task<Option<(String, Option<String>)>> {
        let request = self.request(
            EvaluateCommand {
                expression,
@@ -1801,7 +1801,9 @@ impl Session {
        );
        cx.background_spawn(async move {
            let result = request.await?;
-            result.memory_reference
+            result
+                .memory_reference
+                .map(|reference| (reference, result.type_))
        })
    }

--- a/crates/project/src/manifest_tree/path_trie.rs
+++ b/crates/project/src/manifest_tree/path_trie.rs
@@ -6,7 +6,7 @@ use std::{
    sync::Arc,
 };

-/// [RootPathTrie] is a workhorse of [super::ManifestTree]. It is responsible for determining the closest known project root for a given path.
+/// [RootPathTrie] is a workhorse of [super::ManifestTree]. It is responsible for determining the closest known entry for a given path.
 /// It also determines how much of a given path is unexplored, thus letting callers fill in that gap if needed.
 /// Conceptually, it allows one to annotate Worktree entries with arbitrary extra metadata and run closest-ancestor searches.
 ///
@@ -20,19 +20,16 @@ pub(super) struct RootPathTrie<Label> {
 }

 /// Label presence is a marker that allows to optimize searches within [RootPathTrie]; node label can be:
-/// - Present; we know there's definitely a project root at this node and it is the only label of that kind on the path to the root of a worktree
-/// (none of it's ancestors or descendants can contain the same present label)
+/// - Present; we know there's definitely a project root at this node.
 /// - Known Absent - we know there's definitely no project root at this node and none of it's ancestors are Present (descendants can be present though!).
-/// - Forbidden - we know there's definitely no project root at this node and none of it's ancestors or descendants can be Present.
 /// The distinction is there to optimize searching; when we encounter a node with unknown status, we don't need to look at it's full path
 /// to the root of the worktree; it's sufficient to explore only the path between last node with a KnownAbsent state and the directory of a path, since we run searches
-/// from the leaf up to the root of the worktree. When any of the ancestors is forbidden, we don't need to look at the node or its ancestors.
-/// When there's a present labeled node on the path to the root, we don't need to ask the adapter to run the search at all.
+/// from the leaf up to the root of the worktree.
 ///
 /// In practical terms, it means that by storing label presence we don't need to do a project discovery on a given folder more than once
 /// (unless the node is invalidated, which can happen when FS entries are renamed/removed).
 ///
-/// Storing project absence allows us to recognize which paths have already been scanned for a project root unsuccessfully. This way we don't need to run
+/// Storing absent nodes allows us to recognize which paths have already been scanned for a project root unsuccessfully. This way we don't need to run
 /// such scan more than once.
 #[derive(Clone, Copy, Debug, PartialOrd, PartialEq, Ord, Eq)]
 pub(super) enum LabelPresence {
@@ -237,4 +234,25 @@ mod tests {
            Path::new("a/")
        );
    }
+
+    #[test]
+    fn path_to_a_root_can_contain_multiple_known_nodes() {
+        let mut trie = RootPathTrie::<()>::new();
+        trie.insert(
+            &TriePath::from(Path::new("a/b")),
+            (),
+            LabelPresence::Present,
+        );
+        trie.insert(&TriePath::from(Path::new("a")), (), LabelPresence::Present);
+        let mut visited_paths = BTreeSet::new();
+        trie.walk(&TriePath::from(Path::new("a/b/c")), &mut |path, nodes| {
+            assert_eq!(nodes.get(&()), Some(&LabelPresence::Present));
+            if path.as_ref() != Path::new("a") && path.as_ref() != Path::new("a/b") {
+                panic!("Unexpected path: {}", path.as_ref().display());
+            }
+            assert!(visited_paths.insert(path.clone()));
+            ControlFlow::Continue(())
+        });
+        assert_eq!(visited_paths.len(), 2);
+    }
 }
--- a/crates/project/src/terminals.rs
+++ b/crates/project/src/terminals.rs
@@ -16,7 +16,7 @@ use std::{
 use task::{DEFAULT_REMOTE_SHELL, Shell, ShellBuilder, SpawnInTerminal};
 use terminal::{
    TaskState, TaskStatus, Terminal, TerminalBuilder,
-    terminal_settings::{self, TerminalSettings, VenvSettings},
+    terminal_settings::{self, ActivateScript, TerminalSettings, VenvSettings},
 };
 use util::{
    ResultExt,
@@ -256,8 +256,11 @@ impl Project {
        let (spawn_task, shell) = match kind {
            TerminalKind::Shell(_) => {
                if let Some(python_venv_directory) = &python_venv_directory {
-                    python_venv_activate_command =
-                        this.python_activate_command(python_venv_directory, &settings.detect_venv);
+                    python_venv_activate_command = this.python_activate_command(
+                        python_venv_directory,
+                        &settings.detect_venv,
+                        &settings.shell,
+                    );
                }

                match ssh_details {
@@ -510,10 +513,27 @@ impl Project {
            })
    }

+    fn activate_script_kind(shell: Option<&str>) -> ActivateScript {
+        let shell_env = std::env::var("SHELL").ok();
+        let shell_path = shell.or_else(|| shell_env.as_deref());
+        let shell = std::path::Path::new(shell_path.unwrap_or(""))
+            .file_name()
+            .and_then(|name| name.to_str())
+            .unwrap_or("");
+        match shell {
+            "fish" => ActivateScript::Fish,
+            "tcsh" => ActivateScript::Csh,
+            "nu" => ActivateScript::Nushell,
+            "powershell" | "pwsh" => ActivateScript::PowerShell,
+            _ => ActivateScript::Default,
+        }
+    }
+
    fn python_activate_command(
        &self,
        venv_base_directory: &Path,
        venv_settings: &VenvSettings,
+        shell: &Shell,
    ) -> Option<String> {
        let venv_settings = venv_settings.as_option()?;
        let activate_keyword = match venv_settings.activate_script {
@@ -526,7 +546,22 @@ impl Project {
            terminal_settings::ActivateScript::Pyenv => "pyenv",
            _ => "source",
        };
-        let activate_script_name = match venv_settings.activate_script {
+        let script_kind =
+            if venv_settings.activate_script == terminal_settings::ActivateScript::Default {
+                match shell {
+                    Shell::Program(program) => Self::activate_script_kind(Some(program)),
+                    Shell::WithArguments {
+                        program,
+                        args: _,
+                        title_override: _,
+                    } => Self::activate_script_kind(Some(program)),
+                    Shell::System => Self::activate_script_kind(None),
+                }
+            } else {
+                venv_settings.activate_script
+            };
+
+        let activate_script_name = match script_kind {
            terminal_settings::ActivateScript::Default
            | terminal_settings::ActivateScript::Pyenv => "activate",
            terminal_settings::ActivateScript::Csh => "activate.csh",
--- a/crates/project_panel/src/project_panel.rs
+++ b/crates/project_panel/src/project_panel.rs
@@ -320,6 +320,33 @@ pub fn init(cx: &mut App) {
                });
            }
        });
+
+        workspace.register_action(|workspace, action: &Rename, window, cx| {
+            if let Some(panel) = workspace.panel::<ProjectPanel>(cx) {
+                panel.update(cx, |panel, cx| {
+                    if let Some(first_marked) = panel.marked_entries.first() {
+                        let first_marked = *first_marked;
+                        panel.marked_entries.clear();
+                        panel.selection = Some(first_marked);
+                    }
+                    panel.rename(action, window, cx);
+                });
+            }
+        });
+
+        workspace.register_action(|workspace, action: &Duplicate, window, cx| {
+            if let Some(panel) = workspace.panel::<ProjectPanel>(cx) {
+                panel.update(cx, |panel, cx| {
+                    panel.duplicate(action, window, cx);
+                });
+            }
+        });
+
+        workspace.register_action(|workspace, action: &Delete, window, cx| {
+            if let Some(panel) = workspace.panel::<ProjectPanel>(cx) {
+                panel.update(cx, |panel, cx| panel.delete(action, window, cx));
+            }
+        });
    })
    .detach();
 }
--- a/crates/rules_library/src/rules_library.rs
+++ b/crates/rules_library/src/rules_library.rs
@@ -611,7 +611,7 @@ impl RulesLibrary {
                this.update_in(cx, |this, window, cx| match rule {
                    Ok(rule) => {
                        let title_editor = cx.new(|cx| {
-                            let mut editor = Editor::auto_width(window, cx);
+                            let mut editor = Editor::single_line(window, cx);
                            editor.set_placeholder_text("Untitled", cx);
                            editor.set_text(rule_metadata.title.unwrap_or_default(), window, cx);
                            if prompt_id.is_built_in() {
--- a/crates/settings/src/keymap_file.rs
+++ b/crates/settings/src/keymap_file.rs
@@ -10,6 +10,7 @@ use serde::Deserialize;
 use serde_json::{Value, json};
 use std::borrow::Cow;
 use std::{any::TypeId, fmt::Write, rc::Rc, sync::Arc, sync::LazyLock};
+use util::ResultExt as _;
 use util::{
    asset_str,
    markdown::{MarkdownEscaped, MarkdownInlineCode, MarkdownString},
@@ -612,19 +613,26 @@ impl KeymapFile {
            KeybindUpdateOperation::Replace {
                target_keybind_source: target_source,
                source,
-                ..
+                target,
            } if target_source != KeybindSource::User => {
-                operation = KeybindUpdateOperation::Add(source);
+                operation = KeybindUpdateOperation::Add {
+                    source,
+                    from: Some(target),
+                };
            }
            // if trying to remove a keybinding that is not user-defined, treat it as creating a binding
            // that binds it to `zed::NoAction`
            KeybindUpdateOperation::Remove {
-                mut target,
+                target,
                target_keybind_source,
            } if target_keybind_source != KeybindSource::User => {
-                target.action_name = gpui::NoAction.name();
-                target.action_arguments.take();
-                operation = KeybindUpdateOperation::Add(target);
+                let mut source = target.clone();
+                source.action_name = gpui::NoAction.name();
+                source.action_arguments.take();
+                operation = KeybindUpdateOperation::Add {
+                    source,
+                    from: Some(target),
+                };
            }
            _ => {}
        }
@@ -742,7 +750,10 @@ impl KeymapFile {
                        )
                        .context("Failed to replace keybinding")?;
                    keymap_contents.replace_range(replace_range, &replace_value);
-                    operation = KeybindUpdateOperation::Add(source);
+                    operation = KeybindUpdateOperation::Add {
+                        source,
+                        from: Some(target),
+                    };
                }
            } else {
                log::warn!(
@@ -752,16 +763,28 @@ impl KeymapFile {
                    source.keystrokes,
                    source_action_value,
                );
-                operation = KeybindUpdateOperation::Add(source);
+                operation = KeybindUpdateOperation::Add {
+                    source,
+                    from: Some(target),
+                };
            }
        }

-        if let KeybindUpdateOperation::Add(keybinding) = operation {
+        if let KeybindUpdateOperation::Add {
+            source: keybinding,
+            from,
+        } = operation
+        {
            let mut value = serde_json::Map::with_capacity(4);
            if let Some(context) = keybinding.context {
                value.insert("context".to_string(), context.into());
            }
-            if keybinding.use_key_equivalents {
+            let use_key_equivalents = from.and_then(|from| {
+                let action_value = from.action_value().context("Failed to serialize action value. `use_key_equivalents` on new keybinding may be incorrect.").log_err()?;
+                let (index, _) = find_binding(&keymap, &from, &action_value)?;
+                Some(keymap.0[index].use_key_equivalents)
+            }).unwrap_or(false);
+            if use_key_equivalents {
                value.insert("use_key_equivalents".to_string(), true.into());
            }

@@ -794,9 +817,6 @@ impl KeymapFile {
                if section_context_parsed != target_context_parsed {
                    continue;
                }
-                if section.use_key_equivalents != target.use_key_equivalents {
-                    continue;
-                }
                let Some(bindings) = &section.bindings else {
                    continue;
                };
@@ -827,6 +847,7 @@ impl KeymapFile {
    }
 }

+#[derive(Clone)]
 pub enum KeybindUpdateOperation<'a> {
    Replace {
        /// Describes the keybind to create
@@ -835,24 +856,76 @@ pub enum KeybindUpdateOperation<'a> {
        target: KeybindUpdateTarget<'a>,
        target_keybind_source: KeybindSource,
    },
-    Add(KeybindUpdateTarget<'a>),
+    Add {
+        source: KeybindUpdateTarget<'a>,
+        from: Option<KeybindUpdateTarget<'a>>,
+    },
    Remove {
        target: KeybindUpdateTarget<'a>,
        target_keybind_source: KeybindSource,
    },
 }

-#[derive(Debug)]
+impl KeybindUpdateOperation<'_> {
+    pub fn generate_telemetry(
+        &self,
+    ) -> (
+        // The keybind that is created
+        String,
+        // The keybinding that was removed
+        String,
+        // The source of the keybinding
+        String,
+    ) {
+        let (new_binding, removed_binding, source) = match &self {
+            KeybindUpdateOperation::Replace {
+                source,
+                target,
+                target_keybind_source,
+            } => (Some(source), Some(target), Some(*target_keybind_source)),
+            KeybindUpdateOperation::Add { source, .. } => (Some(source), None, None),
+            KeybindUpdateOperation::Remove {
+                target,
+                target_keybind_source,
+            } => (None, Some(target), Some(*target_keybind_source)),
+        };
+
+        let new_binding = new_binding
+            .map(KeybindUpdateTarget::telemetry_string)
+            .unwrap_or("null".to_owned());
+        let removed_binding = removed_binding
+            .map(KeybindUpdateTarget::telemetry_string)
+            .unwrap_or("null".to_owned());
+
+        let source = source
+            .as_ref()
+            .map(KeybindSource::name)
+            .map(ToOwned::to_owned)
+            .unwrap_or("null".to_owned());
+
+        (new_binding, removed_binding, source)
+    }
+}
+
+impl<'a> KeybindUpdateOperation<'a> {
+    pub fn add(source: KeybindUpdateTarget<'a>) -> Self {
+        Self::Add { source, from: None }
+    }
+}
+
+#[derive(Debug, Clone)]
 pub struct KeybindUpdateTarget<'a> {
    pub context: Option<&'a str>,
    pub keystrokes: &'a [Keystroke],
    pub action_name: &'a str,
-    pub use_key_equivalents: bool,
    pub action_arguments: Option<&'a str>,
 }

 impl<'a> KeybindUpdateTarget<'a> {
    fn action_value(&self) -> Result<Value> {
+        if self.action_name == gpui::NoAction.name() {
+            return Ok(Value::Null);
+        }
        let action_name: Value = self.action_name.into();
        let value = match self.action_arguments {
            Some(args) => {
@@ -874,6 +947,16 @@ impl<'a> KeybindUpdateTarget<'a> {
        keystrokes.pop();
        keystrokes
    }
+
+    fn telemetry_string(&self) -> String {
+        format!(
+            "action_name: {}, context: {}, action_arguments: {}, keystrokes: {}",
+            self.action_name,
+            self.context.unwrap_or("global"),
+            self.action_arguments.unwrap_or("none"),
+            self.keystrokes_unparsed()
+        )
+    }
 }

 #[derive(Clone, Copy, PartialEq, Eq)]
@@ -909,13 +992,17 @@ impl KeybindSource {
    }

    pub fn from_meta(index: KeyBindingMetaIndex) -> Self {
-        match index {
+        Self::try_from_meta(index).unwrap()
+    }
+
+    pub fn try_from_meta(index: KeyBindingMetaIndex) -> Result<Self> {
+        Ok(match index {
            Self::USER => KeybindSource::User,
            Self::BASE => KeybindSource::Base,
            Self::DEFAULT => KeybindSource::Default,
            Self::VIM => KeybindSource::Vim,
-            _ => unreachable!(),
-        }
+            _ => anyhow::bail!("Invalid keybind source {:?}", index),
+        })
    }
 }

@@ -933,6 +1020,7 @@ impl From<KeybindSource> for KeyBindingMetaIndex {

 #[cfg(test)]
 mod tests {
+    use gpui::Keystroke;
    use unindent::Unindent;

    use crate::{
@@ -955,37 +1043,35 @@ mod tests {
        KeymapFile::parse(json).unwrap();
    }

+    #[track_caller]
+    fn check_keymap_update(
+        input: impl ToString,
+        operation: KeybindUpdateOperation,
+        expected: impl ToString,
+    ) {
+        let result = KeymapFile::update_keybinding(operation, input.to_string(), 4)
+            .expect("Update succeeded");
+        pretty_assertions::assert_eq!(expected.to_string(), result);
+    }
+
+    #[track_caller]
+    fn parse_keystrokes(keystrokes: &str) -> Vec<Keystroke> {
+        return keystrokes
+            .split(' ')
+            .map(|s| Keystroke::parse(s).expect("Keystrokes valid"))
+            .collect();
+    }
+
    #[test]
    fn keymap_update() {
-        use gpui::Keystroke;
-
        zlog::init_test();
-        #[track_caller]
-        fn check_keymap_update(
-            input: impl ToString,
-            operation: KeybindUpdateOperation,
-            expected: impl ToString,
-        ) {
-            let result = KeymapFile::update_keybinding(operation, input.to_string(), 4)
-                .expect("Update succeeded");
-            pretty_assertions::assert_eq!(expected.to_string(), result);
-        }
-
-        #[track_caller]
-        fn parse_keystrokes(keystrokes: &str) -> Vec<Keystroke> {
-            return keystrokes
-                .split(' ')
-                .map(|s| Keystroke::parse(s).expect("Keystrokes valid"))
-                .collect();
-        }

        check_keymap_update(
            "[]",
-            KeybindUpdateOperation::Add(KeybindUpdateTarget {
+            KeybindUpdateOperation::add(KeybindUpdateTarget {
                keystrokes: &parse_keystrokes("ctrl-a"),
                action_name: "zed::SomeAction",
                context: None,
-                use_key_equivalents: false,
                action_arguments: None,
            }),
            r#"[
@@ -1007,11 +1093,10 @@ mod tests {
                }
            ]"#
            .unindent(),
-            KeybindUpdateOperation::Add(KeybindUpdateTarget {
+            KeybindUpdateOperation::add(KeybindUpdateTarget {
                keystrokes: &parse_keystrokes("ctrl-b"),
                action_name: "zed::SomeOtherAction",
                context: None,
-                use_key_equivalents: false,
                action_arguments: None,
            }),
            r#"[
@@ -1038,11 +1123,10 @@ mod tests {
                }
            ]"#
            .unindent(),
-            KeybindUpdateOperation::Add(KeybindUpdateTarget {
+            KeybindUpdateOperation::add(KeybindUpdateTarget {
                keystrokes: &parse_keystrokes("ctrl-b"),
                action_name: "zed::SomeOtherAction",
                context: None,
-                use_key_equivalents: false,
                action_arguments: Some(r#"{"foo": "bar"}"#),
            }),
            r#"[
@@ -1074,11 +1158,10 @@ mod tests {
                }
            ]"#
            .unindent(),
-            KeybindUpdateOperation::Add(KeybindUpdateTarget {
+            KeybindUpdateOperation::add(KeybindUpdateTarget {
                keystrokes: &parse_keystrokes("ctrl-b"),
                action_name: "zed::SomeOtherAction",
                context: Some("Zed > Editor && some_condition = true"),
-                use_key_equivalents: true,
                action_arguments: Some(r#"{"foo": "bar"}"#),
            }),
            r#"[
@@ -1089,7 +1172,6 @@ mod tests {
                },
                {
                    "context": "Zed > Editor && some_condition = true",
-                    "use_key_equivalents": true,
                    "bindings": {
                        "ctrl-b": [
                            "zed::SomeOtherAction",
@@ -1117,14 +1199,12 @@ mod tests {
                    keystrokes: &parse_keystrokes("ctrl-a"),
                    action_name: "zed::SomeAction",
                    context: None,
-                    use_key_equivalents: false,
                    action_arguments: None,
                },
                source: KeybindUpdateTarget {
                    keystrokes: &parse_keystrokes("ctrl-b"),
                    action_name: "zed::SomeOtherAction",
                    context: None,
-                    use_key_equivalents: false,
                    action_arguments: Some(r#"{"foo": "bar"}"#),
                },
                target_keybind_source: KeybindSource::Base,
@@ -1163,14 +1243,12 @@ mod tests {
                    keystrokes: &parse_keystrokes("a"),
                    action_name: "zed::SomeAction",
                    context: None,
-                    use_key_equivalents: false,
                    action_arguments: None,
                },
                source: KeybindUpdateTarget {
                    keystrokes: &parse_keystrokes("ctrl-b"),
                    action_name: "zed::SomeOtherAction",
                    context: None,
-                    use_key_equivalents: false,
                    action_arguments: Some(r#"{"foo": "bar"}"#),
                },
                target_keybind_source: KeybindSource::User,
@@ -1204,14 +1282,12 @@ mod tests {
                    keystrokes: &parse_keystrokes("ctrl-a"),
                    action_name: "zed::SomeNonexistentAction",
                    context: None,
-                    use_key_equivalents: false,
                    action_arguments: None,
                },
                source: KeybindUpdateTarget {
                    keystrokes: &parse_keystrokes("ctrl-b"),
                    action_name: "zed::SomeOtherAction",
                    context: None,
-                    use_key_equivalents: false,
                    action_arguments: None,
                },
                target_keybind_source: KeybindSource::User,
@@ -1247,14 +1323,12 @@ mod tests {
                    keystrokes: &parse_keystrokes("ctrl-a"),
                    action_name: "zed::SomeAction",
                    context: None,
-                    use_key_equivalents: false,
                    action_arguments: None,
                },
                source: KeybindUpdateTarget {
                    keystrokes: &parse_keystrokes("ctrl-b"),
                    action_name: "zed::SomeOtherAction",
                    context: None,
-                    use_key_equivalents: false,
                    action_arguments: Some(r#"{"foo": "bar"}"#),
                },
                target_keybind_source: KeybindSource::User,
@@ -1292,14 +1366,12 @@ mod tests {
                    keystrokes: &parse_keystrokes("a"),
                    action_name: "foo::bar",
                    context: Some("SomeContext"),
-                    use_key_equivalents: false,
                    action_arguments: None,
                },
                source: KeybindUpdateTarget {
                    keystrokes: &parse_keystrokes("c"),
                    action_name: "foo::baz",
                    context: Some("SomeOtherContext"),
-                    use_key_equivalents: false,
                    action_arguments: None,
                },
                target_keybind_source: KeybindSource::User,
@@ -1336,14 +1408,12 @@ mod tests {
                    keystrokes: &parse_keystrokes("a"),
                    action_name: "foo::bar",
                    context: Some("SomeContext"),
-                    use_key_equivalents: false,
                    action_arguments: None,
                },
                source: KeybindUpdateTarget {
                    keystrokes: &parse_keystrokes("c"),
                    action_name: "foo::baz",
                    context: Some("SomeOtherContext"),
-                    use_key_equivalents: false,
                    action_arguments: None,
                },
                target_keybind_source: KeybindSource::User,
@@ -1375,7 +1445,6 @@ mod tests {
                    context: Some("SomeContext"),
                    keystrokes: &parse_keystrokes("a"),
                    action_name: "foo::bar",
-                    use_key_equivalents: false,
                    action_arguments: None,
                },
                target_keybind_source: KeybindSource::User,
@@ -1407,7 +1476,6 @@ mod tests {
                    context: Some("SomeContext"),
                    keystrokes: &parse_keystrokes("a"),
                    action_name: "foo::bar",
-                    use_key_equivalents: false,
                    action_arguments: Some("true"),
                },
                target_keybind_source: KeybindSource::User,
@@ -1450,7 +1518,6 @@ mod tests {
                    context: Some("SomeContext"),
                    keystrokes: &parse_keystrokes("a"),
                    action_name: "foo::bar",
-                    use_key_equivalents: false,
                    action_arguments: Some("true"),
                },
                target_keybind_source: KeybindSource::User,
@@ -1471,5 +1538,89 @@ mod tests {
            ]"#
            .unindent(),
        );
+        check_keymap_update(
+            r#"[
+                {
+                    "context": "SomeOtherContext",
+                    "use_key_equivalents": true,
+                    "bindings": {
+                        "b": "foo::bar",
+                    }
+                },
+            ]"#
+            .unindent(),
+            KeybindUpdateOperation::Add {
+                source: KeybindUpdateTarget {
+                    context: Some("SomeContext"),
+                    keystrokes: &parse_keystrokes("a"),
+                    action_name: "foo::baz",
+                    action_arguments: Some("true"),
+                },
+                from: Some(KeybindUpdateTarget {
+                    context: Some("SomeOtherContext"),
+                    keystrokes: &parse_keystrokes("b"),
+                    action_name: "foo::bar",
+                    action_arguments: None,
+                }),
+            },
+            r#"[
+                {
+                    "context": "SomeOtherContext",
+                    "use_key_equivalents": true,
+                    "bindings": {
+                        "b": "foo::bar",
+                    }
+                },
+                {
+                    "context": "SomeContext",
+                    "use_key_equivalents": true,
+                    "bindings": {
+                        "a": [
+                            "foo::baz",
+                            true
+                        ]
+                    }
+                }
+            ]"#
+            .unindent(),
+        );
+
+        check_keymap_update(
+            r#"[
+                {
+                    "context": "SomeOtherContext",
+                    "use_key_equivalents": true,
+                    "bindings": {
+                        "b": "foo::bar",
+                    }
+                },
+            ]"#
+            .unindent(),
+            KeybindUpdateOperation::Remove {
+                target: KeybindUpdateTarget {
+                    context: Some("SomeContext"),
+                    keystrokes: &parse_keystrokes("a"),
+                    action_name: "foo::baz",
+                    action_arguments: Some("true"),
+                },
+                target_keybind_source: KeybindSource::Default,
+            },
+            r#"[
+                {
+                    "context": "SomeOtherContext",
+                    "use_key_equivalents": true,
+                    "bindings": {
+                        "b": "foo::bar",
+                    }
+                },
+                {
+                    "context": "SomeContext",
+                    "bindings": {
+                        "a": null
+                    }
+                }
+            ]"#
+            .unindent(),
+        );
    }
 }
--- a/crates/settings/src/settings_json.rs
+++ b/crates/settings/src/settings_json.rs
@@ -437,17 +437,19 @@ pub fn append_top_level_array_value_in_json_text(
    );
    debug_assert_eq!(cursor.node().kind(), "]");
    let close_bracket_start = cursor.node().start_byte();
-    cursor.goto_previous_sibling();
-    while (cursor.node().is_extra() || cursor.node().is_missing()) && cursor.goto_previous_sibling()
-    {
-    }
+    while cursor.goto_previous_sibling()
+        && (cursor.node().is_extra() || cursor.node().is_missing())
+        && !cursor.node().is_error()
+    {}

    let mut comma_range = None;
    let mut prev_item_range = None;

-    if cursor.node().kind() == "," {
+    if cursor.node().kind() == "," || is_error_of_kind(&mut cursor, ",") {
        comma_range = Some(cursor.node().byte_range());
-        while cursor.goto_previous_sibling() && cursor.node().is_extra() {}
+        while cursor.goto_previous_sibling()
+            && (cursor.node().is_extra() || cursor.node().is_missing())
+        {}

        debug_assert_ne!(cursor.node().kind(), "[");
        prev_item_range = Some(cursor.node().range());
@@ -514,6 +516,17 @@ pub fn append_top_level_array_value_in_json_text(
        replace_value.push('\n');
    }
    return Ok((replace_range, replace_value));
+
+    fn is_error_of_kind(cursor: &mut tree_sitter::TreeCursor<'_>, kind: &str) -> bool {
+        if cursor.node().kind() != "ERROR" {
+            return false;
+        }
+
+        let descendant_index = cursor.descendant_index();
+        let res = cursor.goto_first_child() && cursor.node().kind() == kind;
+        cursor.goto_descendant(descendant_index);
+        return res;
+    }
 }

 pub fn to_pretty_json(
--- a/crates/settings_ui/Cargo.toml
+++ b/crates/settings_ui/Cargo.toml
@@ -34,6 +34,7 @@ search.workspace = true
 serde.workspace = true
 serde_json.workspace = true
 settings.workspace = true
+telemetry.workspace = true
 theme.workspace = true
 tree-sitter-json.workspace = true
 tree-sitter-rust.workspace = true
--- a/crates/settings_ui/src/keybindings.rs
+++ b/crates/settings_ui/src/keybindings.rs
--- a/crates/settings_ui/src/ui_components/table.rs
+++ b/crates/settings_ui/src/ui_components/table.rs
@@ -40,6 +40,10 @@ impl<const COLS: usize> TableContents<COLS> {
            TableContents::UniformList(data) => data.row_count,
        }
    }
+
+    fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
 }

 pub struct TableInteractionState {
@@ -375,6 +379,7 @@ pub struct Table<const COLS: usize = 3> {
    interaction_state: Option<WeakEntity<TableInteractionState>>,
    column_widths: Option<[Length; COLS]>,
    map_row: Option<Rc<dyn Fn((usize, Div), &mut Window, &mut App) -> AnyElement>>,
+    empty_table_callback: Option<Rc<dyn Fn(&mut Window, &mut App) -> AnyElement>>,
 }

 impl<const COLS: usize> Table<COLS> {
@@ -388,6 +393,7 @@ impl<const COLS: usize> Table<COLS> {
            interaction_state: None,
            column_widths: None,
            map_row: None,
+            empty_table_callback: None,
        }
    }

@@ -460,6 +466,15 @@ impl<const COLS: usize> Table<COLS> {
        self.map_row = Some(Rc::new(callback));
        self
    }
+
+    /// Provide a callback that is invoked when the table is rendered without any rows
+    pub fn empty_table_callback(
+        mut self,
+        callback: impl Fn(&mut Window, &mut App) -> AnyElement + 'static,
+    ) -> Self {
+        self.empty_table_callback = Some(Rc::new(callback));
+        self
+    }
 }

 fn base_cell_style(width: Option<Length>, cx: &App) -> Div {
@@ -582,6 +597,7 @@ impl<const COLS: usize> RenderOnce for Table<COLS> {
        };

        let width = self.width;
+        let no_rows_rendered = self.rows.is_empty();

        let table = div()
            .when_some(width, |this, width| this.w(width))
@@ -662,6 +678,21 @@ impl<const COLS: usize> RenderOnce for Table<COLS> {
                        })
                    }),
            )
+            .when_some(
+                no_rows_rendered
+                    .then_some(self.empty_table_callback)
+                    .flatten(),
+                |this, callback| {
+                    this.child(
+                        h_flex()
+                            .size_full()
+                            .p_3()
+                            .items_start()
+                            .justify_center()
+                            .child(callback(window, cx)),
+                    )
+                },
+            )
            .when_some(
                width.and(interaction_state.as_ref()),
                |this, interaction_state| {
--- a/crates/terminal/src/terminal_settings.rs
+++ b/crates/terminal/src/terminal_settings.rs
@@ -123,7 +123,7 @@ impl VenvSettings {
    }
 }

-#[derive(Clone, Copy, Debug, Default, Serialize, Deserialize, JsonSchema)]
+#[derive(Clone, Copy, Debug, Default, PartialEq, Serialize, Deserialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub enum ActivateScript {
    #[default]
--- a/crates/terminal_view/src/terminal_view.rs
+++ b/crates/terminal_view/src/terminal_view.rs
@@ -25,11 +25,11 @@ use terminal::{
    TaskStatus, Terminal, TerminalBounds, ToggleViMode,
    alacritty_terminal::{
        index::Point,
-        term::{TermMode, search::RegexSearch},
+        term::{TermMode, point_to_viewport, search::RegexSearch},
    },
    terminal_settings::{self, CursorShape, TerminalBlink, TerminalSettings, WorkingDirectory},
 };
-use terminal_element::{TerminalElement, is_blank};
+use terminal_element::TerminalElement;
 use terminal_panel::TerminalPanel;
 use terminal_scrollbar::TerminalScrollHandle;
 use terminal_slash_command::TerminalSlashCommand;
@@ -497,25 +497,14 @@ impl TerminalView {
        };

        let line_height = terminal.last_content().terminal_bounds.line_height;
-        let mut terminal_lines = terminal.total_lines();
        let viewport_lines = terminal.viewport_lines();
-        if terminal.total_lines() == terminal.viewport_lines() {
-            let mut last_line = None;
-            for cell in terminal.last_content.cells.iter().rev() {
-                if !is_blank(cell) {
-                    break;
-                }
-
-                let last_line = last_line.get_or_insert(cell.point.line);
-                if *last_line != cell.point.line {
-                    terminal_lines -= 1;
-                }
-                *last_line = cell.point.line;
-            }
-        }
-
+        let cursor = point_to_viewport(
+            terminal.last_content.display_offset,
+            terminal.last_content.cursor.point,
+        )
+        .unwrap_or_default();
        let max_scroll_top_in_lines =
-            (block.height as usize).saturating_sub(viewport_lines.saturating_sub(terminal_lines));
+            (block.height as usize).saturating_sub(viewport_lines.saturating_sub(cursor.line + 1));

        max_scroll_top_in_lines as f32 * line_height
    }
--- a/crates/theme_selector/src/icon_theme_selector.rs
+++ b/crates/theme_selector/src/icon_theme_selector.rs
@@ -327,6 +327,7 @@ impl PickerDelegate for IconThemeSelectorDelegate {
                            window.dispatch_action(
                                Box::new(Extensions {
                                    category_filter: Some(ExtensionCategoryFilter::IconThemes),
+                                    id: None,
                                }),
                                cx,
                            );
--- a/crates/theme_selector/src/theme_selector.rs
+++ b/crates/theme_selector/src/theme_selector.rs
@@ -385,6 +385,7 @@ impl PickerDelegate for ThemeSelectorDelegate {
                            window.dispatch_action(
                                Box::new(Extensions {
                                    category_filter: Some(ExtensionCategoryFilter::Themes),
+                                    id: None,
                                }),
                                cx,
                            );
--- a/crates/title_bar/Cargo.toml
+++ b/crates/title_bar/Cargo.toml
@@ -40,6 +40,7 @@ rpc.workspace = true
 schemars.workspace = true
 serde.workspace = true
 settings.workspace = true
+settings_ui.workspace = true
 smallvec.workspace = true
 story = { workspace = true, optional = true }
 telemetry.workspace = true
--- a/crates/title_bar/src/title_bar.rs
+++ b/crates/title_bar/src/title_bar.rs
@@ -30,11 +30,12 @@ use onboarding_banner::OnboardingBanner;
 use project::Project;
 use rpc::proto;
 use settings::Settings as _;
+use settings_ui::keybindings;
 use std::sync::Arc;
 use theme::ActiveTheme;
 use title_bar_settings::TitleBarSettings;
 use ui::{
-    Avatar, Button, ButtonLike, ButtonStyle, ContextMenu, Icon, IconName, IconSize,
+    Avatar, Button, ButtonLike, ButtonStyle, Chip, ContextMenu, Icon, IconName, IconSize,
    IconWithIndicator, Indicator, PopoverMenu, Tooltip, h_flex, prelude::*,
 };
 use util::ResultExt;
@@ -631,25 +632,59 @@ impl TitleBar {
                // Since the user might be on the legacy free plan we filter based on whether we have a subscription period.
                has_subscription_period
            });
+
+            let user_avatar = user.avatar_uri.clone();
+            let free_chip_bg = cx
+                .theme()
+                .colors()
+                .editor_background
+                .opacity(0.5)
+                .blend(cx.theme().colors().text_accent.opacity(0.05));
+
+            let pro_chip_bg = cx
+                .theme()
+                .colors()
+                .editor_background
+                .opacity(0.5)
+                .blend(cx.theme().colors().text_accent.opacity(0.2));
+
            PopoverMenu::new("user-menu")
                .anchor(Corner::TopRight)
                .menu(move |window, cx| {
                    ContextMenu::build(window, cx, |menu, _, _cx| {
-                        menu.link(
-                            format!(
-                                "Current Plan: {}",
-                                match plan {
-                                    None => "None",
-                                    Some(proto::Plan::Free) => "Zed Free",
-                                    Some(proto::Plan::ZedPro) => "Zed Pro",
-                                    Some(proto::Plan::ZedProTrial) => "Zed Pro (Trial)",
-                                }
-                            ),
-                            zed_actions::OpenAccountSettings.boxed_clone(),
+                        let user_login = user.github_login.clone();
+
+                        let (plan_name, label_color, bg_color) = match plan {
+                            None => ("None", Color::Default, free_chip_bg),
+                            Some(proto::Plan::Free) => ("Free", Color::Default, free_chip_bg),
+                            Some(proto::Plan::ZedProTrial) => {
+                                ("Pro Trial", Color::Accent, pro_chip_bg)
+                            }
+                            Some(proto::Plan::ZedPro) => ("Pro", Color::Accent, pro_chip_bg),
+                        };
+
+                        menu.custom_entry(
+                            move |_window, _cx| {
+                                let user_login = user_login.clone();
+
+                                h_flex()
+                                    .w_full()
+                                    .justify_between()
+                                    .child(Label::new(user_login))
+                                    .child(
+                                        Chip::new(plan_name.to_string())
+                                            .bg_color(bg_color)
+                                            .label_color(label_color),
+                                    )
+                                    .into_any_element()
+                            },
+                            move |_, cx| {
+                                cx.open_url("https://zed.dev/account");
+                            },
                        )
                        .separator()
                        .action("Settings", zed_actions::OpenSettings.boxed_clone())
-                        .action("Key Bindings", Box::new(zed_actions::OpenKeymap))
+                        .action("Key Bindings", Box::new(keybindings::OpenKeymapEditor))
                        .action(
                            "Themes…",
                            zed_actions::theme_selector::Toggle::default().boxed_clone(),
@@ -675,7 +710,7 @@ impl TitleBar {
                                .children(
                                    TitleBarSettings::get_global(cx)
                                        .show_user_picture
-                                        .then(|| Avatar::new(user.avatar_uri.clone())),
+                                        .then(|| Avatar::new(user_avatar)),
                                )
                                .child(
                                    Icon::new(IconName::ChevronDown)
@@ -693,7 +728,7 @@ impl TitleBar {
                .menu(|window, cx| {
                    ContextMenu::build(window, cx, |menu, _, _| {
                        menu.action("Settings", zed_actions::OpenSettings.boxed_clone())
-                            .action("Key Bindings", Box::new(zed_actions::OpenKeymap))
+                            .action("Key Bindings", Box::new(keybindings::OpenKeymapEditor))
                            .action(
                                "Themes…",
                                zed_actions::theme_selector::Toggle::default().boxed_clone(),
--- a/crates/ui/src/components.rs
+++ b/crates/ui/src/components.rs
@@ -2,6 +2,7 @@ mod avatar;
 mod banner;
 mod button;
 mod callout;
+mod chip;
 mod content_group;
 mod context_menu;
 mod disclosure;
@@ -43,6 +44,7 @@ pub use avatar::*;
 pub use banner::*;
 pub use button::*;
 pub use callout::*;
+pub use chip::*;
 pub use content_group::*;
 pub use context_menu::*;
 pub use disclosure::*;
--- a/crates/ui/src/components/banner.rs
+++ b/crates/ui/src/components/banner.rs
@@ -19,8 +19,8 @@ pub enum Severity {
 /// use ui::{Banner};
 ///
 ///    Banner::new()
-///     .severity(Severity::Info)
-///     .children(Label::new("This is an informational message"))
+///     .severity(Severity::Success)
+///     .children(Label::new("This is a success message"))
 ///     .action_slot(
 ///         Button::new("learn-more", "Learn More")
 ///             .icon(IconName::ArrowUpRight)
@@ -32,7 +32,6 @@ pub enum Severity {
 pub struct Banner {
    severity: Severity,
    children: Vec<AnyElement>,
-    icon: Option<(IconName, Option<Color>)>,
    action_slot: Option<AnyElement>,
 }

@@ -42,7 +41,6 @@ impl Banner {
        Self {
            severity: Severity::Info,
            children: Vec::new(),
-            icon: None,
            action_slot: None,
        }
    }
@@ -53,12 +51,6 @@ impl Banner {
        self
    }

-    /// Sets an icon to display in the banner with an optional color.
-    pub fn icon(mut self, icon: IconName, color: Option<impl Into<Color>>) -> Self {
-        self.icon = Some((icon, color.map(|c| c.into())));
-        self
-    }
-
    /// A slot for actions, such as CTA or dismissal buttons.
    pub fn action_slot(mut self, element: impl IntoElement) -> Self {
        self.action_slot = Some(element.into_any_element());
@@ -73,12 +65,13 @@ impl ParentElement for Banner {
 }

 impl RenderOnce for Banner {
-    fn render(self, _window: &mut Window, cx: &mut App) -> impl IntoElement {
-        let base = h_flex()
+    fn render(self, window: &mut Window, cx: &mut App) -> impl IntoElement {
+        let banner = h_flex()
            .py_0p5()
-            .rounded_sm()
+            .gap_1p5()
            .flex_wrap()
            .justify_between()
+            .rounded_sm()
            .border_1();

        let (icon, icon_color, bg_color, border_color) = match self.severity {
@@ -108,29 +101,31 @@ impl RenderOnce for Banner {
            ),
        };

-        let mut container = base.bg(bg_color).border_color(border_color);
+        let mut banner = banner.bg(bg_color).border_color(border_color);

-        let mut content_area = h_flex().id("content_area").gap_1p5().overflow_x_scroll();
-
-        if self.icon.is_none() {
-            content_area =
-                content_area.child(Icon::new(icon).size(IconSize::XSmall).color(icon_color));
-        }
-
-        content_area = content_area.children(self.children);
+        let icon_and_child = h_flex()
+            .items_start()
+            .min_w_0()
+            .gap_1p5()
+            .child(
+                h_flex()
+                    .h(window.line_height())
+                    .flex_shrink_0()
+                    .child(Icon::new(icon).size(IconSize::XSmall).color(icon_color)),
+            )
+            .child(div().min_w_0().children(self.children));

        if let Some(action_slot) = self.action_slot {
-            container = container
+            banner = banner
                .pl_2()
-                .pr_0p5()
-                .gap_2()
-                .child(content_area)
+                .pr_1()
+                .child(icon_and_child)
                .child(action_slot);
        } else {
-            container = container.px_2().child(div().w_full().child(content_area));
+            banner = banner.px_2().child(icon_and_child);
        }

-        container
+        banner
    }
 }

--- a/crates/ui/src/components/chip.rs
+++ b/crates/ui/src/components/chip.rs
@@ -0,0 +1,106 @@
+use crate::prelude::*;
+use gpui::{AnyElement, Hsla, IntoElement, ParentElement, Styled};
+
+/// Chips provide a container for an informative label.
+///
+/// # Usage Example
+///
+/// ```
+/// use ui::{Chip};
+///
+///    Chip::new("This Chip")
+/// ```
+#[derive(IntoElement, RegisterComponent)]
+pub struct Chip {
+    label: SharedString,
+    label_color: Color,
+    label_size: LabelSize,
+    bg_color: Option<Hsla>,
+}
+
+impl Chip {
+    /// Creates a new `Chip` component with the specified label.
+    pub fn new(label: impl Into<SharedString>) -> Self {
+        Self {
+            label: label.into(),
+            label_color: Color::Default,
+            label_size: LabelSize::XSmall,
+            bg_color: None,
+        }
+    }
+
+    /// Sets the color of the label.
+    pub fn label_color(mut self, color: Color) -> Self {
+        self.label_color = color;
+        self
+    }
+
+    /// Sets the size of the label.
+    pub fn label_size(mut self, size: LabelSize) -> Self {
+        self.label_size = size;
+        self
+    }
+
+    /// Sets a custom background color for the callout content.
+    pub fn bg_color(mut self, color: Hsla) -> Self {
+        self.bg_color = Some(color);
+        self
+    }
+}
+
+impl RenderOnce for Chip {
+    fn render(self, _: &mut Window, cx: &mut App) -> impl IntoElement {
+        let bg_color = self
+            .bg_color
+            .unwrap_or(cx.theme().colors().element_background);
+
+        h_flex()
+            .min_w_0()
+            .flex_initial()
+            .px_1()
+            .border_1()
+            .rounded_sm()
+            .border_color(cx.theme().colors().border)
+            .bg(bg_color)
+            .overflow_hidden()
+            .child(
+                Label::new(self.label)
+                    .size(self.label_size)
+                    .color(self.label_color)
+                    .buffer_font(cx),
+            )
+    }
+}
+
+impl Component for Chip {
+    fn scope() -> ComponentScope {
+        ComponentScope::DataDisplay
+    }
+
+    fn preview(_window: &mut Window, cx: &mut App) -> Option<AnyElement> {
+        let chip_examples = vec![
+            single_example("Default", Chip::new("Chip Example").into_any_element()),
+            single_example(
+                "Customized Label Color",
+                Chip::new("Chip Example")
+                    .label_color(Color::Accent)
+                    .into_any_element(),
+            ),
+            single_example(
+                "Customized Label Size",
+                Chip::new("Chip Example")
+                    .label_size(LabelSize::Large)
+                    .label_color(Color::Accent)
+                    .into_any_element(),
+            ),
+            single_example(
+                "Customized Background Color",
+                Chip::new("Chip Example")
+                    .bg_color(cx.theme().colors().text_accent.opacity(0.1))
+                    .into_any_element(),
+            ),
+        ];
+
+        Some(example_group(chip_examples).vertical().into_any_element())
+    }
+}
--- a/crates/ui/src/components/context_menu.rs
+++ b/crates/ui/src/components/context_menu.rs
@@ -972,12 +972,10 @@ impl ContextMenu {
                            .children(action.as_ref().and_then(|action| {
                                self.action_context
                                    .as_ref()
-                                    .map(|focus| {
+                                    .and_then(|focus| {
                                        KeyBinding::for_action_in(&**action, focus, window, cx)
                                    })
-                                    .unwrap_or_else(|| {
-                                        KeyBinding::for_action(&**action, window, cx)
-                                    })
+                                    .or_else(|| KeyBinding::for_action(&**action, window, cx))
                                    .map(|binding| {
                                        div().ml_4().child(binding.disabled(*disabled)).when(
                                            *disabled && documentation_aside.is_some(),
--- a/crates/ui/src/components/keybinding_hint.rs
+++ b/crates/ui/src/components/keybinding_hint.rs
@@ -206,7 +206,7 @@ impl RenderOnce for KeybindingHint {

 impl Component for KeybindingHint {
    fn scope() -> ComponentScope {
-        ComponentScope::None
+        ComponentScope::DataDisplay
    }

    fn description() -> Option<&'static str> {
--- a/crates/ui/src/components/tooltip.rs
+++ b/crates/ui/src/components/tooltip.rs
@@ -274,7 +274,7 @@ impl Render for LinkPreview {

 impl Component for Tooltip {
    fn scope() -> ComponentScope {
-        ComponentScope::None
+        ComponentScope::DataDisplay
    }

    fn description() -> Option<&'static str> {
--- a/crates/ui_input/src/ui_input.rs
+++ b/crates/ui_input/src/ui_input.rs
@@ -135,6 +135,7 @@ impl Render for SingleLineInput {
        let editor_style = EditorStyle {
            background: theme_color.ghost_element_background,
            local_player: cx.theme().players().local(),
+            syntax: cx.theme().syntax().clone(),
            text: text_style,
            ..Default::default()
        };
--- a/crates/workspace/src/workspace.rs
+++ b/crates/workspace/src/workspace.rs
@@ -1711,6 +1711,27 @@ impl Workspace {
        history
    }

+    pub fn recent_active_item_by_type<T: 'static>(&self, cx: &App) -> Option<Entity<T>> {
+        let mut recent_item: Option<Entity<T>> = None;
+        let mut recent_timestamp = 0;
+        for pane_handle in &self.panes {
+            let pane = pane_handle.read(cx);
+            let item_map: HashMap<EntityId, &Box<dyn ItemHandle>> =
+                pane.items().map(|item| (item.item_id(), item)).collect();
+            for entry in pane.activation_history() {
+                if entry.timestamp > recent_timestamp {
+                    if let Some(&item) = item_map.get(&entry.entity_id) {
+                        if let Some(typed_item) = item.act_as::<T>(cx) {
+                            recent_timestamp = entry.timestamp;
+                            recent_item = Some(typed_item);
+                        }
+                    }
+                }
+            }
+        }
+        recent_item
+    }
+
    pub fn recent_navigation_history_iter(
        &self,
        cx: &App,
--- a/crates/x_ai/Cargo.toml
+++ b/crates/x_ai/Cargo.toml
@@ -0,0 +1,23 @@
+[package]
+name = "x_ai"
+version = "0.1.0"
+edition.workspace = true
+publish.workspace = true
+license = "GPL-3.0-or-later"
+
+[lints]
+workspace = true
+
+[lib]
+path = "src/x_ai.rs"
+
+[features]
+default = []
+schemars = ["dep:schemars"]
+
+[dependencies]
+anyhow.workspace = true
+schemars = { workspace = true, optional = true }
+serde.workspace = true
+strum.workspace = true
+workspace-hack.workspace = true
--- a/crates/x_ai/LICENSE-GPL
+++ b/crates/x_ai/LICENSE-GPL
@@ -0,0 +1 @@
+../../LICENSE-GPL
--- a/crates/x_ai/src/x_ai.rs
+++ b/crates/x_ai/src/x_ai.rs
@@ -0,0 +1,126 @@
+use anyhow::Result;
+use serde::{Deserialize, Serialize};
+use strum::EnumIter;
+
+pub const XAI_API_URL: &str = "https://api.x.ai/v1";
+
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Clone, Debug, Default, Serialize, Deserialize, PartialEq, EnumIter)]
+pub enum Model {
+    #[serde(rename = "grok-2-vision-latest")]
+    Grok2Vision,
+    #[default]
+    #[serde(rename = "grok-3-latest")]
+    Grok3,
+    #[serde(rename = "grok-3-mini-latest")]
+    Grok3Mini,
+    #[serde(rename = "grok-3-fast-latest")]
+    Grok3Fast,
+    #[serde(rename = "grok-3-mini-fast-latest")]
+    Grok3MiniFast,
+    #[serde(rename = "grok-4-latest")]
+    Grok4,
+    #[serde(rename = "custom")]
+    Custom {
+        name: String,
+        /// The name displayed in the UI, such as in the assistant panel model dropdown menu.
+        display_name: Option<String>,
+        max_tokens: u64,
+        max_output_tokens: Option<u64>,
+        max_completion_tokens: Option<u64>,
+    },
+}
+
+impl Model {
+    pub fn default_fast() -> Self {
+        Self::Grok3Fast
+    }
+
+    pub fn from_id(id: &str) -> Result<Self> {
+        match id {
+            "grok-2-vision" => Ok(Self::Grok2Vision),
+            "grok-3" => Ok(Self::Grok3),
+            "grok-3-mini" => Ok(Self::Grok3Mini),
+            "grok-3-fast" => Ok(Self::Grok3Fast),
+            "grok-3-mini-fast" => Ok(Self::Grok3MiniFast),
+            _ => anyhow::bail!("invalid model id '{id}'"),
+        }
+    }
+
+    pub fn id(&self) -> &str {
+        match self {
+            Self::Grok2Vision => "grok-2-vision",
+            Self::Grok3 => "grok-3",
+            Self::Grok3Mini => "grok-3-mini",
+            Self::Grok3Fast => "grok-3-fast",
+            Self::Grok3MiniFast => "grok-3-mini-fast",
+            Self::Grok4 => "grok-4",
+            Self::Custom { name, .. } => name,
+        }
+    }
+
+    pub fn display_name(&self) -> &str {
+        match self {
+            Self::Grok2Vision => "Grok 2 Vision",
+            Self::Grok3 => "Grok 3",
+            Self::Grok3Mini => "Grok 3 Mini",
+            Self::Grok3Fast => "Grok 3 Fast",
+            Self::Grok3MiniFast => "Grok 3 Mini Fast",
+            Self::Grok4 => "Grok 4",
+            Self::Custom {
+                name, display_name, ..
+            } => display_name.as_ref().unwrap_or(name),
+        }
+    }
+
+    pub fn max_token_count(&self) -> u64 {
+        match self {
+            Self::Grok3 | Self::Grok3Mini | Self::Grok3Fast | Self::Grok3MiniFast => 131_072,
+            Self::Grok4 => 256_000,
+            Self::Grok2Vision => 8_192,
+            Self::Custom { max_tokens, .. } => *max_tokens,
+        }
+    }
+
+    pub fn max_output_tokens(&self) -> Option<u64> {
+        match self {
+            Self::Grok3 | Self::Grok3Mini | Self::Grok3Fast | Self::Grok3MiniFast => Some(8_192),
+            Self::Grok4 => Some(64_000),
+            Self::Grok2Vision => Some(4_096),
+            Self::Custom {
+                max_output_tokens, ..
+            } => *max_output_tokens,
+        }
+    }
+
+    pub fn supports_parallel_tool_calls(&self) -> bool {
+        match self {
+            Self::Grok2Vision
+            | Self::Grok3
+            | Self::Grok3Mini
+            | Self::Grok3Fast
+            | Self::Grok3MiniFast
+            | Self::Grok4 => true,
+            Model::Custom { .. } => false,
+        }
+    }
+
+    pub fn supports_tool(&self) -> bool {
+        match self {
+            Self::Grok2Vision
+            | Self::Grok3
+            | Self::Grok3Mini
+            | Self::Grok3Fast
+            | Self::Grok3MiniFast
+            | Self::Grok4 => true,
+            Model::Custom { .. } => false,
+        }
+    }
+
+    pub fn supports_images(&self) -> bool {
+        match self {
+            Self::Grok2Vision => true,
+            _ => false,
+        }
+    }
+}
--- a/crates/zed/Cargo.toml
+++ b/crates/zed/Cargo.toml
@@ -2,7 +2,7 @@
 description = "The fast, collaborative code editor."
 edition.workspace = true
 name = "zed"
-version = "0.196.0"
+version = "0.196.4"
 publish.workspace = true
 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
+preview
--- a/crates/zed/src/main.rs
+++ b/crates/zed/src/main.rs
@@ -746,6 +746,23 @@ fn handle_open_request(request: OpenRequest, app_state: Arc<AppState>, cx: &mut
        return;
    }

+    if let Some(extension) = request.extension_id {
+        cx.spawn(async move |cx| {
+            let workspace = workspace::get_any_active_workspace(app_state, cx.clone()).await?;
+            workspace.update(cx, |_, window, cx| {
+                window.dispatch_action(
+                    Box::new(zed_actions::Extensions {
+                        category_filter: None,
+                        id: Some(extension),
+                    }),
+                    cx,
+                );
+            })
+        })
+        .detach_and_log_err(cx);
+        return;
+    }
+
    if let Some(connection_options) = request.ssh_connection {
        cx.spawn(async move |mut cx| {
            let paths: Vec<PathBuf> = request.open_paths.into_iter().map(PathBuf::from).collect();
--- a/crates/zed/src/zed/app_menus.rs
+++ b/crates/zed/src/zed/app_menus.rs
@@ -1,5 +1,6 @@
 use collab_ui::collab_panel;
 use gpui::{Menu, MenuItem, OsAction};
+use settings_ui::keybindings;
 use terminal_view::terminal_panel;

 pub fn app_menus() -> Vec<Menu> {
@@ -16,7 +17,7 @@ pub fn app_menus() -> Vec<Menu> {
                    name: "Settings".into(),
                    items: vec![
                        MenuItem::action("Open Settings", super::OpenSettings),
-                        MenuItem::action("Open Key Bindings", zed_actions::OpenKeymap),
+                        MenuItem::action("Open Key Bindings", keybindings::OpenKeymapEditor),
                        MenuItem::action("Open Default Settings", super::OpenDefaultSettings),
                        MenuItem::action(
                            "Open Default Key Bindings",
--- a/Show More
+++ b/Show More
				`@@ -0,0 +1 @@`
				`<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-equal-icon lucide-equal"><line x1="5" x2="19" y1="9" y2="9"/><line x1="5" x2="19" y1="15" y2="15"/></svg>`