Create parent of .zed/debug.json if needed

.github/ISSUE_TEMPLATE/04_bug_debugger.yml

@@ -1,35 +0,0 @@
-name: Bug Report (Debugger)
-description: Zed Debugger-Related Bugs
-type: "Bug"
-labels: ["debugger"]
-title: "Debugger: <a short description of the Debugger bug>"
-body:
-  - type: textarea
-    attributes:
-      label: Summary
-      description: Describe the bug with a one line summary, and provide detailed reproduction steps
-      value: |
-        <!-- Please insert a one line summary of the issue below -->
-        SUMMARY_SENTENCE_HERE
-
-        ### Description
-        <!--  Describe with sufficient detail to reproduce from a clean Zed install. -->
-        Steps to trigger the problem:
-        1.
-        2.
-        3.
-
-        Actual Behavior:
-        Expected Behavior:
-
-    validations:
-      required: true
-  - type: textarea
-    id: environment
-    attributes:
-      label: Zed Version and System Specs
-      description: 'Open Zed, and in the command palette select "zed: Copy System Specs Into Clipboard"'
-      placeholder: |
-        Output of "zed: Copy System Specs Into Clipboard"
-    validations:
-      required: true

.gitignore

@@ -2,7 +2,6 @@
 **/cargo-target
 **/target
 **/venv
-**/.direnv
 *.wasm
 *.xcodeproj
 .DS_Store

Cargo.lock

@@ -3309,7 +3309,6 @@ dependencies = [
  "http_client",
  "indoc",
  "inline_completion",
- "itertools 0.14.0",
  "language",
  "log",
  "lsp",
@@ -3319,9 +3318,11 @@ dependencies = [
  "paths",
  "project",
  "rpc",
+ "schemars",
  "serde",
  "serde_json",
  "settings",
+ "strum 0.27.1",
  "task",
  "theme",
  "ui",
@@ -4134,18 +4135,6 @@ dependencies = [
  "winapi",
 ]
 
-[[package]]
-name = "debug_adapter_extension"
-version = "0.1.0"
-dependencies = [
- "anyhow",
- "async-trait",
- "dap",
- "extension",
- "gpui",
- "workspace-hack",
-]
-
 [[package]]
 name = "debugger_tools"
 version = "0.1.0"
@@ -4179,7 +4168,6 @@ dependencies = [
  "editor",
  "env_logger 0.11.8",
  "feature_flags",
- "file_icons",
  "futures 0.3.31",
  "fuzzy",
  "gpui",
@@ -4195,7 +4183,6 @@ dependencies = [
  "serde",
  "serde_json",
  "settings",
- "shlex",
  "sysinfo",
  "task",
  "tasks_ui",
@@ -5051,7 +5038,6 @@ dependencies = [
  "async-tar",
  "async-trait",
  "collections",
- "dap",
  "fs",
  "futures 0.3.31",
  "gpui",
@@ -5064,7 +5050,6 @@ dependencies = [
  "semantic_version",
  "serde",
  "serde_json",
- "task",
  "toml 0.8.20",
  "util",
  "wasm-encoder 0.221.3",
@@ -5108,7 +5093,6 @@ dependencies = [
  "client",
  "collections",
  "ctor",
- "dap",
  "env_logger 0.11.8",
  "extension",
  "fs",
@@ -7241,6 +7225,7 @@ dependencies = [
  "lsp",
  "paths",
  "project",
+ "proto",
  "regex",
  "serde_json",
  "settings",
@@ -7248,6 +7233,7 @@ dependencies = [
  "telemetry",
  "theme",
  "ui",
+ "util",
  "workspace",
  "workspace-hack",
  "zed_actions",
@@ -10053,7 +10039,7 @@ name = "perplexity"
 version = "0.1.0"
 dependencies = [
  "serde",
- "zed_extension_api 0.6.0",
+ "zed_extension_api 0.5.0",
 ]
 
 [[package]]
@@ -18033,6 +18019,7 @@ dependencies = [
  "aho-corasick",
  "anstream",
  "arrayvec",
+ "async-compression",
  "async-std",
  "async-tungstenite",
  "aws-config",
@@ -18540,7 +18527,7 @@ dependencies = [
 
 [[package]]
 name = "zed"
-version = "0.187.1"
+version = "0.187.0"
 dependencies = [
  "activity_indicator",
  "agent",
@@ -18710,7 +18697,7 @@ dependencies = [
 
 [[package]]
 name = "zed_extension_api"
-version = "0.6.0"
+version = "0.5.0"
 dependencies = [
  "serde",
  "serde_json",
@@ -18770,7 +18757,7 @@ dependencies = [
 name = "zed_test_extension"
 version = "0.1.0"
 dependencies = [
- "zed_extension_api 0.6.0",
+ "zed_extension_api 0.5.0",
 ]
 
 [[package]]

Cargo.toml

@@ -37,7 +37,6 @@ members = [
     "crates/dap",
     "crates/dap_adapters",
     "crates/db",
-    "crates/debug_adapter_extension",
     "crates/debugger_tools",
     "crates/debugger_ui",
     "crates/deepseek",
@@ -244,7 +243,6 @@ credentials_provider = { path = "crates/credentials_provider" }
 dap = { path = "crates/dap" }
 dap_adapters = { path = "crates/dap_adapters" }
 db = { path = "crates/db" }
-debug_adapter_extension = { path = "crates/debug_adapter_extension" }
 debugger_tools = { path = "crates/debugger_tools" }
 debugger_ui = { path = "crates/debugger_ui" }
 deepseek = { path = "crates/deepseek" }

assets/keymaps/default-linux.json

@@ -244,7 +244,7 @@
       "ctrl-shift-a": "agent::ToggleContextPicker",
       "ctrl-shift-o": "agent::ToggleNavigationMenu",
       "ctrl-shift-i": "agent::ToggleOptionsMenu",
-      "shift-alt-escape": "agent::ExpandMessageEditor",
+      "shift-escape": "agent::ExpandMessageEditor",
       "ctrl-alt-e": "agent::RemoveAllContext",
       "ctrl-shift-e": "project_panel::ToggleFocus"
     }
@@ -538,7 +538,6 @@
       "ctrl-alt-b": "workspace::ToggleRightDock",
       "ctrl-b": "workspace::ToggleLeftDock",
       "ctrl-j": "workspace::ToggleBottomDock",
-      "ctrl-w": "workspace::CloseActiveDock",
       "ctrl-alt-y": "workspace::CloseAllDocks",
       "shift-find": "pane::DeploySearch",
       "ctrl-shift-f": "pane::DeploySearch",
@@ -979,12 +978,5 @@
     "bindings": {
       "ctrl-r": "diagnostics::ToggleDiagnosticsRefresh"
     }
-  },
-  {
-    "context": "DebugConsole > Editor",
-    "use_key_equivalents": true,
-    "bindings": {
-      "enter": "menu::Confirm"
-    }
   }
 ]

assets/keymaps/default-macos.json

@@ -290,7 +290,7 @@
       "cmd-shift-a": "agent::ToggleContextPicker",
       "cmd-shift-o": "agent::ToggleNavigationMenu",
       "cmd-shift-i": "agent::ToggleOptionsMenu",
-      "shift-alt-escape": "agent::ExpandMessageEditor",
+      "shift-escape": "agent::ExpandMessageEditor",
       "cmd-alt-e": "agent::RemoveAllContext",
       "cmd-shift-e": "project_panel::ToggleFocus"
     }
@@ -608,7 +608,6 @@
       "cmd-b": "workspace::ToggleLeftDock",
       "cmd-r": "workspace::ToggleRightDock",
       "cmd-j": "workspace::ToggleBottomDock",
-      "cmd-w": "workspace::CloseActiveDock",
       "alt-cmd-y": "workspace::CloseAllDocks",
       "cmd-shift-f": "pane::DeploySearch",
       "cmd-shift-h": ["pane::DeploySearch", { "replace_enabled": true }],
@@ -1085,12 +1084,5 @@
     "bindings": {
       "ctrl-r": "diagnostics::ToggleDiagnosticsRefresh"
     }
-  },
-  {
-    "context": "DebugConsole > Editor",
-    "use_key_equivalents": true,
-    "bindings": {
-      "enter": "menu::Confirm"
-    }
   }
 ]

assets/settings/default.json

@@ -113,8 +113,8 @@
   // Whether to show the informational hover box when moving the mouse
   // over symbols in the editor.
   "hover_popover_enabled": true,
-  // Time to wait in milliseconds before showing the informational hover box.
-  "hover_popover_delay": 300,
+  // Time to wait before showing the informational hover box
+  "hover_popover_delay": 350,
   // Whether to confirm before quitting Zed.
   "confirm_quit": false,
   // Whether to restore last closed project when fresh Zed instance is opened.
@@ -328,10 +328,6 @@
   "title_bar": {
     // Whether to show the branch icon beside branch switcher in the titlebar.
     "show_branch_icon": false,
-    // Whether to show the branch name button in the titlebar.
-    "show_branch_name": true,
-    // Whether to show the project host and name in the titlebar.
-    "show_project_items": true,
     // Whether to show onboarding banners in the titlebar.
     "show_onboarding_banner": true,
     // Whether to show user picture in the titlebar.
@@ -474,8 +470,6 @@
   "search_wrap": true,
   // Search options to enable by default when opening new project and buffer searches.
   "search": {
-    // Whether to show the project search button in the status bar.
-    "button": true,
     "whole_word": false,
     "case_sensitive": false,
     "include_ignored": false,
@@ -1008,8 +1002,6 @@
   "auto_update": true,
   // Diagnostics configuration.
   "diagnostics": {
-    // Whether to show the project diagnostics button in the status bar.
-    "button": true,
     // Whether to show warnings or not by default.
     "include_warnings": true,
     // Settings for inline diagnostics

crates/agent/src/active_thread.rs

@@ -33,9 +33,7 @@ use language_model::{
     LanguageModelRequestMessage, LanguageModelToolUseId, MessageContent, Role, StopReason,
 };
 use markdown::parser::{CodeBlockKind, CodeBlockMetadata};
-use markdown::{
-    HeadingLevelStyles, Markdown, MarkdownElement, MarkdownStyle, ParsedMarkdown, PathWithRange,
-};
+use markdown::{HeadingLevelStyles, Markdown, MarkdownElement, MarkdownStyle, ParsedMarkdown};
 use project::{ProjectEntryId, ProjectItem as _};
 use rope::Point;
 use settings::{Settings as _, SettingsStore, update_settings_file};
@@ -383,25 +381,18 @@ fn render_markdown_code_block(
                 )
             } else {
                 let content = if let Some(parent) = path_range.path.parent() {
-                    let file_name = file_name.to_string_lossy().to_string();
-                    let path = parent.to_string_lossy().to_string();
-                    let path_and_file = format!("{}/{}", path, file_name);
-
                     h_flex()
-                        .id(("code-block-header-label", ix))
                         .ml_1()
                         .gap_1()
-                        .child(Label::new(file_name).size(LabelSize::Small))
-                        .child(Label::new(path).color(Color::Muted).size(LabelSize::Small))
-                        .tooltip(move |window, cx| {
-                            Tooltip::with_meta(
-                                "Jump to File",
-                                None,
-                                path_and_file.clone(),
-                                window,
-                                cx,
-                            )
-                        })
+                        .child(
+                            Label::new(file_name.to_string_lossy().to_string())
+                                .size(LabelSize::Small),
+                        )
+                        .child(
+                            Label::new(parent.to_string_lossy().to_string())
+                                .color(Color::Muted)
+                                .size(LabelSize::Small),
+                        )
                         .into_any_element()
                 } else {
                     Label::new(path_range.path.to_string_lossy().to_string())
@@ -411,7 +402,7 @@ fn render_markdown_code_block(
                 };
 
                 h_flex()
-                    .id(("code-block-header-button", ix))
+                    .id(("code-block-header-label", ix))
                     .w_full()
                     .max_w_full()
                     .px_1()
@@ -419,6 +410,7 @@ fn render_markdown_code_block(
                     .cursor_pointer()
                     .rounded_sm()
                     .hover(|item| item.bg(cx.theme().colors().element_hover.opacity(0.5)))
+                    .tooltip(Tooltip::text("Jump to File"))
                     .child(
                         h_flex()
                             .gap_0p5()
@@ -438,8 +430,49 @@ fn render_markdown_code_block(
                         let path_range = path_range.clone();
                         move |_, window, cx| {
                             workspace
-                                .update(cx, |workspace, cx| {
-                                    open_path(&path_range, window, workspace, cx)
+                                .update(cx, {
+                                    |workspace, cx| {
+                                        let Some(project_path) = workspace
+                                            .project()
+                                            .read(cx)
+                                            .find_project_path(&path_range.path, cx)
+                                        else {
+                                            return;
+                                        };
+                                        let Some(target) = path_range.range.as_ref().map(|range| {
+                                            Point::new(
+                                                // Line number is 1-based
+                                                range.start.line.saturating_sub(1),
+                                                range.start.col.unwrap_or(0),
+                                            )
+                                        }) else {
+                                            return;
+                                        };
+                                        let open_task = workspace.open_path(
+                                            project_path,
+                                            None,
+                                            true,
+                                            window,
+                                            cx,
+                                        );
+                                        window
+                                            .spawn(cx, async move |cx| {
+                                                let item = open_task.await?;
+                                                if let Some(active_editor) =
+                                                    item.downcast::<Editor>()
+                                                {
+                                                    active_editor
+                                                        .update_in(cx, |editor, window, cx| {
+                                                            editor.go_to_singleton_buffer_point(
+                                                                target, window, cx,
+                                                            );
+                                                        })
+                                                        .ok();
+                                                }
+                                                anyhow::Ok(())
+                                            })
+                                            .detach_and_log_err(cx);
+                                    }
                                 })
                                 .ok();
                         }
@@ -454,10 +487,15 @@ fn render_markdown_code_block(
         .copied_code_block_ids
         .contains(&(message_id, ix));
 
-    let can_expand = metadata.line_count >= MAX_UNCOLLAPSED_LINES_IN_CODE_BLOCK;
+    let can_expand = metadata.line_count > MAX_UNCOLLAPSED_LINES_IN_CODE_BLOCK;
 
     let is_expanded = if can_expand {
-        active_thread.read(cx).is_codeblock_expanded(message_id, ix)
+        active_thread
+            .read(cx)
+            .expanded_code_blocks
+            .get(&(message_id, ix))
+            .copied()
+            .unwrap_or(false)
     } else {
         false
     };
@@ -468,87 +506,10 @@ fn render_markdown_code_block(
         .element_background
         .blend(cx.theme().colors().editor_foreground.opacity(0.01));
 
-    let control_buttons = h_flex()
-        .visible_on_hover(CODEBLOCK_CONTAINER_GROUP)
-        .absolute()
-        .top_0()
-        .right_0()
-        .h_full()
-        .bg(codeblock_header_bg)
-        .rounded_tr_md()
-        .px_1()
-        .gap_1()
-        .child(
-            IconButton::new(
-                ("copy-markdown-code", ix),
-                if codeblock_was_copied {
-                    IconName::Check
-                } else {
-                    IconName::Copy
-                },
-            )
-            .icon_color(Color::Muted)
-            .shape(ui::IconButtonShape::Square)
-            .tooltip(Tooltip::text("Copy Code"))
-            .on_click({
-                let active_thread = active_thread.clone();
-                let parsed_markdown = parsed_markdown.clone();
-                let code_block_range = metadata.content_range.clone();
-                move |_event, _window, cx| {
-                    active_thread.update(cx, |this, cx| {
-                        this.copied_code_block_ids.insert((message_id, ix));
-
-                        let code = parsed_markdown.source()[code_block_range.clone()].to_string();
-                        cx.write_to_clipboard(ClipboardItem::new_string(code));
-
-                        cx.spawn(async move |this, cx| {
-                            cx.background_executor().timer(Duration::from_secs(2)).await;
-
-                            cx.update(|cx| {
-                                this.update(cx, |this, cx| {
-                                    this.copied_code_block_ids.remove(&(message_id, ix));
-                                    cx.notify();
-                                })
-                            })
-                            .ok();
-                        })
-                        .detach();
-                    });
-                }
-            }),
-        )
-        .when(can_expand, |header| {
-            header.child(
-                IconButton::new(
-                    ("expand-collapse-code", ix),
-                    if is_expanded {
-                        IconName::ChevronUp
-                    } else {
-                        IconName::ChevronDown
-                    },
-                )
-                .icon_color(Color::Muted)
-                .shape(ui::IconButtonShape::Square)
-                .tooltip(Tooltip::text(if is_expanded {
-                    "Collapse Code"
-                } else {
-                    "Expand Code"
-                }))
-                .on_click({
-                    let active_thread = active_thread.clone();
-                    move |_event, _window, cx| {
-                        active_thread.update(cx, |this, cx| {
-                            this.toggle_codeblock_expanded(message_id, ix);
-                            cx.notify();
-                        });
-                    }
-                }),
-            )
-        });
-
     let codeblock_header = h_flex()
-        .relative()
-        .p_1()
+        .py_1()
+        .pl_1p5()
+        .pr_1()
         .gap_1()
         .justify_between()
         .border_b_1()
@@ -556,7 +517,83 @@ fn render_markdown_code_block(
         .bg(codeblock_header_bg)
         .rounded_t_md()
         .children(label)
-        .child(control_buttons);
+        .child(
+            h_flex()
+                .visible_on_hover(CODEBLOCK_CONTAINER_GROUP)
+                .gap_1()
+                .child(
+                    IconButton::new(
+                        ("copy-markdown-code", ix),
+                        if codeblock_was_copied {
+                            IconName::Check
+                        } else {
+                            IconName::Copy
+                        },
+                    )
+                    .icon_color(Color::Muted)
+                    .shape(ui::IconButtonShape::Square)
+                    .tooltip(Tooltip::text("Copy Code"))
+                    .on_click({
+                        let active_thread = active_thread.clone();
+                        let parsed_markdown = parsed_markdown.clone();
+                        let code_block_range = metadata.content_range.clone();
+                        move |_event, _window, cx| {
+                            active_thread.update(cx, |this, cx| {
+                                this.copied_code_block_ids.insert((message_id, ix));
+
+                                let code =
+                                    parsed_markdown.source()[code_block_range.clone()].to_string();
+                                cx.write_to_clipboard(ClipboardItem::new_string(code));
+
+                                cx.spawn(async move |this, cx| {
+                                    cx.background_executor().timer(Duration::from_secs(2)).await;
+
+                                    cx.update(|cx| {
+                                        this.update(cx, |this, cx| {
+                                            this.copied_code_block_ids.remove(&(message_id, ix));
+                                            cx.notify();
+                                        })
+                                    })
+                                    .ok();
+                                })
+                                .detach();
+                            });
+                        }
+                    }),
+                )
+                .when(can_expand, |header| {
+                    header.child(
+                        IconButton::new(
+                            ("expand-collapse-code", ix),
+                            if is_expanded {
+                                IconName::ChevronUp
+                            } else {
+                                IconName::ChevronDown
+                            },
+                        )
+                        .icon_color(Color::Muted)
+                        .shape(ui::IconButtonShape::Square)
+                        .tooltip(Tooltip::text(if is_expanded {
+                            "Collapse Code"
+                        } else {
+                            "Expand Code"
+                        }))
+                        .on_click({
+                            let active_thread = active_thread.clone();
+                            move |_event, _window, cx| {
+                                active_thread.update(cx, |this, cx| {
+                                    let is_expanded = this
+                                        .expanded_code_blocks
+                                        .entry((message_id, ix))
+                                        .or_insert(true);
+                                    *is_expanded = !*is_expanded;
+                                    cx.notify();
+                                });
+                            }
+                        }),
+                    )
+                }),
+        );
 
     v_flex()
         .group(CODEBLOCK_CONTAINER_GROUP)
@@ -570,45 +607,6 @@ fn render_markdown_code_block(
         .when(can_expand && !is_expanded, |this| this.max_h_80())
 }
 
-fn open_path(
-    path_range: &PathWithRange,
-    window: &mut Window,
-    workspace: &mut Workspace,
-    cx: &mut Context<'_, Workspace>,
-) {
-    let Some(project_path) = workspace
-        .project()
-        .read(cx)
-        .find_project_path(&path_range.path, cx)
-    else {
-        return; // TODO instead of just bailing out, open that path in a buffer.
-    };
-
-    let Some(target) = path_range.range.as_ref().map(|range| {
-        Point::new(
-            // Line number is 1-based
-            range.start.line.saturating_sub(1),
-            range.start.col.unwrap_or(0),
-        )
-    }) else {
-        return;
-    };
-    let open_task = workspace.open_path(project_path, None, true, window, cx);
-    window
-        .spawn(cx, async move |cx| {
-            let item = open_task.await?;
-            if let Some(active_editor) = item.downcast::<Editor>() {
-                active_editor
-                    .update_in(cx, |editor, window, cx| {
-                        editor.go_to_singleton_buffer_point(target, window, cx);
-                    })
-                    .ok();
-            }
-            anyhow::Ok(())
-        })
-        .detach_and_log_err(cx);
-}
-
 fn render_code_language(
     language: Option<&Arc<Language>>,
     name_fallback: SharedString,
@@ -2358,14 +2356,17 @@ impl ActiveThread {
 
                                             move |el, range, metadata, _, cx| {
                                                 let can_expand = metadata.line_count
-                                                    >= MAX_UNCOLLAPSED_LINES_IN_CODE_BLOCK;
+                                                    > MAX_UNCOLLAPSED_LINES_IN_CODE_BLOCK;
                                                 if !can_expand {
                                                     return el;
                                                 }
 
                                                 let is_expanded = active_thread
                                                     .read(cx)
-                                                    .is_codeblock_expanded(message_id, range.start);
+                                                    .expanded_code_blocks
+                                                    .get(&(message_id, range.start))
+                                                    .copied()
+                                                    .unwrap_or(false);
                                                 if is_expanded {
                                                     return el;
                                                 }
@@ -3383,21 +3384,6 @@ impl ActiveThread {
                 .log_err();
         }))
     }
-
-    pub fn is_codeblock_expanded(&self, message_id: MessageId, ix: usize) -> bool {
-        self.expanded_code_blocks
-            .get(&(message_id, ix))
-            .copied()
-            .unwrap_or(false)
-    }
-
-    pub fn toggle_codeblock_expanded(&mut self, message_id: MessageId, ix: usize) {
-        let is_expanded = self
-            .expanded_code_blocks
-            .entry((message_id, ix))
-            .or_insert(false);
-        *is_expanded = !*is_expanded;
-    }
 }
 
 pub enum ActiveThreadEvent {

crates/agent/src/agent.rs

@@ -49,7 +49,7 @@ pub use crate::context::{ContextLoadResult, LoadedContext};
 pub use crate::inline_assistant::InlineAssistant;
 use crate::slash_command_settings::SlashCommandSettings;
 pub use crate::thread::{Message, MessageSegment, Thread, ThreadEvent};
-pub use crate::thread_store::{SerializedThread, TextThreadStore, ThreadStore};
+pub use crate::thread_store::{TextThreadStore, ThreadStore};
 pub use agent_diff::{AgentDiffPane, AgentDiffToolbar};
 pub use context_store::ContextStore;
 pub use ui::preview::{all_agent_previews, get_agent_preview};

crates/agent/src/agent_configuration.rs

@@ -36,7 +36,6 @@ pub struct AgentConfiguration {
     configuration_views_by_provider: HashMap<LanguageModelProviderId, AnyView>,
     context_server_store: Entity<ContextServerStore>,
     expanded_context_server_tools: HashMap<ContextServerId, bool>,
-    expanded_provider_configurations: HashMap<LanguageModelProviderId, bool>,
     tools: Entity<ToolWorkingSet>,
     _registry_subscription: Subscription,
     scroll_handle: ScrollHandle,
@@ -79,7 +78,6 @@ impl AgentConfiguration {
             configuration_views_by_provider: HashMap::default(),
             context_server_store,
             expanded_context_server_tools: HashMap::default(),
-            expanded_provider_configurations: HashMap::default(),
             tools,
             _registry_subscription: registry_subscription,
             scroll_handle,
@@ -98,7 +96,6 @@ impl AgentConfiguration {
 
     fn remove_provider_configuration_view(&mut self, provider_id: &LanguageModelProviderId) {
         self.configuration_views_by_provider.remove(provider_id);
-        self.expanded_provider_configurations.remove(provider_id);
     }
 
     fn add_provider_configuration_view(
@@ -138,14 +135,9 @@ impl AgentConfiguration {
             .get(&provider.id())
             .cloned();
 
-        let is_expanded = self
-            .expanded_provider_configurations
-            .get(&provider.id())
-            .copied()
-            .unwrap_or(true);
-
         v_flex()
             .pt_3()
+            .pb_1()
             .gap_1p5()
             .border_t_1()
             .border_color(cx.theme().colors().border.opacity(0.6))
@@ -160,59 +152,32 @@ 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(Label::new(provider_name.clone()).size(LabelSize::Large)),
                     )
-                    .child(
-                        h_flex()
-                            .gap_1()
-                            .when(provider.is_authenticated(cx), |parent| {
-                                parent.child(
-                                    Button::new(
-                                        SharedString::from(format!("new-thread-{provider_id}")),
-                                        "Start New Thread",
-                                    )
-                                    .icon_position(IconPosition::Start)
-                                    .icon(IconName::Plus)
-                                    .icon_size(IconSize::Small)
-                                    .layer(ElevationIndex::ModalSurface)
-                                    .label_size(LabelSize::Small)
-                                    .on_click(cx.listener({
-                                        let provider = provider.clone();
-                                        move |_this, _event, _window, cx| {
-                                            cx.emit(AssistantConfigurationEvent::NewThread(
-                                                provider.clone(),
-                                            ))
-                                        }
-                                    })),
-                                )
-                            })
-                            .child(
-                                Disclosure::new(
-                                    SharedString::from(format!(
-                                        "provider-disclosure-{provider_id}"
-                                    )),
-                                    is_expanded,
-                                )
-                                .opened_icon(IconName::ChevronUp)
-                                .closed_icon(IconName::ChevronDown)
-                                .on_click(cx.listener({
-                                    let provider_id = provider.id().clone();
-                                    move |this, _event, _window, _cx| {
-                                        let is_open = this
-                                            .expanded_provider_configurations
-                                            .entry(provider_id.clone())
-                                            .or_insert(true);
-
-                                        *is_open = !*is_open;
-                                    }
-                                })),
-                            ),
-                    ),
+                    .when(provider.is_authenticated(cx), |parent| {
+                        parent.child(
+                            Button::new(
+                                SharedString::from(format!("new-thread-{provider_id}")),
+                                "Start New Thread",
+                            )
+                            .icon_position(IconPosition::Start)
+                            .icon(IconName::Plus)
+                            .icon_size(IconSize::Small)
+                            .style(ButtonStyle::Filled)
+                            .layer(ElevationIndex::ModalSurface)
+                            .label_size(LabelSize::Small)
+                            .on_click(cx.listener({
+                                let provider = provider.clone();
+                                move |_this, _event, _window, cx| {
+                                    cx.emit(AssistantConfigurationEvent::NewThread(
+                                        provider.clone(),
+                                    ))
+                                }
+                            })),
+                        )
+                    }),
             )
-            .when(is_expanded, |parent| match configuration_view {
+            .map(|parent| match configuration_view {
                 Some(configuration_view) => parent.child(configuration_view),
                 None => parent.child(div().child(Label::new(format!(
                     "No configuration view for {provider_name}",
@@ -422,7 +387,6 @@ impl AgentConfiguration {
             .unwrap_or(ContextServerStatus::Stopped);
 
         let is_running = matches!(server_status, ContextServerStatus::Running);
-        let item_id = SharedString::from(context_server_id.0.clone());
 
         let error = if let ContextServerStatus::Error(error) = server_status.clone() {
             Some(error)
@@ -444,38 +408,9 @@ impl AgentConfiguration {
         let tool_count = tools.len();
 
         let border_color = cx.theme().colors().border.opacity(0.6);
-        let success_color = Color::Success.color(cx);
-
-        let (status_indicator, tooltip_text) = match server_status {
-            ContextServerStatus::Starting => (
-                Indicator::dot()
-                    .color(Color::Success)
-                    .with_animation(
-                        SharedString::from(format!("{}-starting", context_server_id.0.clone(),)),
-                        Animation::new(Duration::from_secs(2))
-                            .repeat()
-                            .with_easing(pulsating_between(0.4, 1.)),
-                        move |this, delta| this.color(success_color.alpha(delta).into()),
-                    )
-                    .into_any_element(),
-                "Server is starting.",
-            ),
-            ContextServerStatus::Running => (
-                Indicator::dot().color(Color::Success).into_any_element(),
-                "Server is running.",
-            ),
-            ContextServerStatus::Error(_) => (
-                Indicator::dot().color(Color::Error).into_any_element(),
-                "Server has an error.",
-            ),
-            ContextServerStatus::Stopped => (
-                Indicator::dot().color(Color::Muted).into_any_element(),
-                "Server is stopped.",
-            ),
-        };
 
         v_flex()
-            .id(item_id.clone())
+            .id(SharedString::from(context_server_id.0.clone()))
             .border_1()
             .rounded_md()
             .border_color(border_color)
@@ -510,12 +445,35 @@ impl AgentConfiguration {
                                     }
                                 })),
                             )
-                            .child(
-                                div()
-                                    .id(item_id.clone())
-                                    .tooltip(Tooltip::text(tooltip_text))
-                                    .child(status_indicator),
-                            )
+                            .child(match server_status {
+                                ContextServerStatus::Starting => {
+                                    let color = Color::Success.color(cx);
+                                    Indicator::dot()
+                                        .color(Color::Success)
+                                        .with_animation(
+                                            SharedString::from(format!(
+                                                "{}-starting",
+                                                context_server_id.0.clone(),
+                                            )),
+                                            Animation::new(Duration::from_secs(2))
+                                                .repeat()
+                                                .with_easing(pulsating_between(0.4, 1.)),
+                                            move |this, delta| {
+                                                this.color(color.alpha(delta).into())
+                                            },
+                                        )
+                                        .into_any_element()
+                                }
+                                ContextServerStatus::Running => {
+                                    Indicator::dot().color(Color::Success).into_any_element()
+                                }
+                                ContextServerStatus::Error(_) => {
+                                    Indicator::dot().color(Color::Error).into_any_element()
+                                }
+                                ContextServerStatus::Stopped => {
+                                    Indicator::dot().color(Color::Muted).into_any_element()
+                                }
+                            })
                             .child(Label::new(context_server_id.0.clone()).ml_0p5())
                             .when(is_running, |this| {
                                 this.child(

crates/agent/src/agent_panel.rs

@@ -1648,12 +1648,6 @@ impl AgentPanel {
                 }),
         );
 
-        let zoom_in_label = if self.is_zoomed(window, cx) {
-            "Zoom Out"
-        } else {
-            "Zoom In"
-        };
-
         let agent_extra_menu = PopoverMenu::new("agent-options-menu")
             .trigger_with_tooltip(
                 IconButton::new("agent-options-menu", IconName::Ellipsis)
@@ -1740,8 +1734,7 @@ impl AgentPanel {
 
                     menu = menu
                         .action("Rules…", Box::new(OpenRulesLibrary::default()))
-                        .action("Settings", Box::new(OpenConfiguration))
-                        .action(zoom_in_label, Box::new(ToggleZoom));
+                        .action("Settings", Box::new(OpenConfiguration));
                     menu
                 }))
             });
@@ -2439,6 +2432,9 @@ impl AgentPanel {
                 .occlude()
                 .child(match last_error {
                     ThreadError::PaymentRequired => self.render_payment_required_error(cx),
+                    ThreadError::MaxMonthlySpendReached => {
+                        self.render_max_monthly_spend_reached_error(cx)
+                    }
                     ThreadError::ModelRequestLimitReached { plan } => {
                         self.render_model_request_limit_reached_error(plan, cx)
                     }
@@ -2498,6 +2494,56 @@ impl AgentPanel {
             .into_any()
     }
 
+    fn render_max_monthly_spend_reached_error(&self, cx: &mut Context<Self>) -> AnyElement {
+        const ERROR_MESSAGE: &str = "You have reached your maximum monthly spend. Increase your spend limit to continue using Zed LLMs.";
+
+        v_flex()
+            .gap_0p5()
+            .child(
+                h_flex()
+                    .gap_1p5()
+                    .items_center()
+                    .child(Icon::new(IconName::XCircle).color(Color::Error))
+                    .child(Label::new("Max Monthly Spend Reached").weight(FontWeight::MEDIUM)),
+            )
+            .child(
+                div()
+                    .id("error-message")
+                    .max_h_24()
+                    .overflow_y_scroll()
+                    .child(Label::new(ERROR_MESSAGE)),
+            )
+            .child(
+                h_flex()
+                    .justify_end()
+                    .mt_1()
+                    .gap_1()
+                    .child(self.create_copy_button(ERROR_MESSAGE))
+                    .child(
+                        Button::new("subscribe", "Update Monthly Spend Limit").on_click(
+                            cx.listener(|this, _, _, cx| {
+                                this.thread.update(cx, |this, _cx| {
+                                    this.clear_last_error();
+                                });
+
+                                cx.open_url(&zed_urls::account_url(cx));
+                                cx.notify();
+                            }),
+                        ),
+                    )
+                    .child(Button::new("dismiss", "Dismiss").on_click(cx.listener(
+                        |this, _, _, cx| {
+                            this.thread.update(cx, |this, _cx| {
+                                this.clear_last_error();
+                            });
+
+                            cx.notify();
+                        },
+                    ))),
+            )
+            .into_any()
+    }
+
     fn render_model_request_limit_reached_error(
         &self,
         plan: Plan,

crates/agent/src/inline_assistant.rs

@@ -338,27 +338,13 @@ impl InlineAssistant {
         window: &mut Window,
         cx: &mut App,
     ) {
-        let (snapshot, initial_selections, newest_selection) = editor.update(cx, |editor, cx| {
-            let selections = editor.selections.all::<Point>(cx);
-            let newest_selection = editor.selections.newest::<Point>(cx);
-            (editor.snapshot(window, cx), selections, newest_selection)
+        let (snapshot, initial_selections) = editor.update(cx, |editor, cx| {
+            (
+                editor.snapshot(window, cx),
+                editor.selections.all::<Point>(cx),
+            )
         });
 
-        // Check if there is already an inline assistant that contains the
-        // newest selection, if there is, focus it
-        if let Some(editor_assists) = self.assists_by_editor.get(&editor.downgrade()) {
-            for assist_id in &editor_assists.assist_ids {
-                let assist = &self.assists[assist_id];
-                let range = assist.range.to_point(&snapshot.buffer_snapshot);
-                if range.start.row <= newest_selection.start.row
-                    && newest_selection.end.row <= range.end.row
-                {
-                    self.focus_assist(*assist_id, window, cx);
-                    return;
-                }
-            }
-        }
-
         let mut selections = Vec::<Selection<Point>>::new();
         let mut newest_selection = None;
         for mut selection in initial_selections {

crates/agent/src/thread.rs

@@ -22,7 +22,7 @@ use language_model::{
     ConfiguredModel, LanguageModel, LanguageModelCompletionError, LanguageModelCompletionEvent,
     LanguageModelId, LanguageModelKnownError, LanguageModelRegistry, LanguageModelRequest,
     LanguageModelRequestMessage, LanguageModelRequestTool, LanguageModelToolResult,
-    LanguageModelToolResultContent, LanguageModelToolUseId, MessageContent,
+    LanguageModelToolUseId, MaxMonthlySpendReachedError, MessageContent,
     ModelRequestLimitReachedError, PaymentRequiredError, RequestUsage, Role, SelectedModel,
     StopReason, TokenUsage,
 };
@@ -458,7 +458,7 @@ impl Thread {
         tools: Entity<ToolWorkingSet>,
         prompt_builder: Arc<PromptBuilder>,
         project_context: SharedProjectContext,
-        window: Option<&mut Window>, // None in headless mode
+        window: &mut Window,
         cx: &mut Context<Self>,
     ) -> Self {
         let next_message_id = MessageId(
@@ -880,13 +880,7 @@ impl Thread {
     }
 
     pub fn output_for_tool(&self, id: &LanguageModelToolUseId) -> Option<&Arc<str>> {
-        match &self.tool_use.tool_result(id)?.content {
-            LanguageModelToolResultContent::Text(str) => Some(str),
-            LanguageModelToolResultContent::Image(_) => {
-                // TODO: We should display image
-                None
-            }
-        }
+        Some(&self.tool_use.tool_result(id)?.content)
     }
 
     pub fn card_for_tool(&self, id: &LanguageModelToolUseId) -> Option<AnyToolCard> {
@@ -1688,6 +1682,10 @@ impl Thread {
 
                             if error.is::<PaymentRequiredError>() {
                                 cx.emit(ThreadEvent::ShowError(ThreadError::PaymentRequired));
+                            } else if error.is::<MaxMonthlySpendReachedError>() {
+                                cx.emit(ThreadEvent::ShowError(
+                                    ThreadError::MaxMonthlySpendReached,
+                                ));
                             } else if let Some(error) =
                                 error.downcast_ref::<ModelRequestLimitReachedError>()
                             {
@@ -2243,7 +2241,7 @@ impl Thread {
             .read(cx)
             .enabled_tools(cx)
             .iter()
-            .map(|tool| tool.name())
+            .map(|tool| tool.name().to_string())
             .collect();
 
         self.message_feedback.insert(message_id, feedback);
@@ -2504,15 +2502,7 @@ impl Thread {
                 }
 
                 writeln!(markdown, "**\n")?;
-                match &tool_result.content {
-                    LanguageModelToolResultContent::Text(str) => {
-                        writeln!(markdown, "{}", str)?;
-                    }
-                    LanguageModelToolResultContent::Image(image) => {
-                        writeln!(markdown, "![Image](data:base64,{})", image.source)?;
-                    }
-                }
-
+                writeln!(markdown, "{}", tool_result.content)?;
                 if let Some(output) = tool_result.output.as_ref() {
                     writeln!(
                         markdown,
@@ -2702,6 +2692,8 @@ impl Thread {
 pub enum ThreadError {
     #[error("Payment required")]
     PaymentRequired,
+    #[error("Max monthly spend reached")]
+    MaxMonthlySpendReached,
     #[error("Model request limit reached")]
     ModelRequestLimitReached { plan: Plan },
     #[error("Message {header}: {message}")]

crates/agent/src/thread_store.rs

@@ -19,7 +19,7 @@ use gpui::{
 };
 use heed::Database;
 use heed::types::SerdeBincode;
-use language_model::{LanguageModelToolResultContent, LanguageModelToolUseId, Role, TokenUsage};
+use language_model::{LanguageModelToolUseId, Role, TokenUsage};
 use project::context_server_store::{ContextServerStatus, ContextServerStore};
 use project::{Project, ProjectItem, ProjectPath, Worktree};
 use prompt_store::{
@@ -386,25 +386,6 @@ impl ThreadStore {
         })
     }
 
-    pub fn create_thread_from_serialized(
-        &mut self,
-        serialized: SerializedThread,
-        cx: &mut Context<Self>,
-    ) -> Entity<Thread> {
-        cx.new(|cx| {
-            Thread::deserialize(
-                ThreadId::new(),
-                serialized,
-                self.project.clone(),
-                self.tools.clone(),
-                self.prompt_builder.clone(),
-                self.project_context.clone(),
-                None,
-                cx,
-            )
-        })
-    }
-
     pub fn open_thread(
         &self,
         id: &ThreadId,
@@ -430,7 +411,7 @@ impl ThreadStore {
                         this.tools.clone(),
                         this.prompt_builder.clone(),
                         this.project_context.clone(),
-                        Some(window),
+                        window,
                         cx,
                     )
                 })
@@ -505,8 +486,8 @@ impl ThreadStore {
                 ToolSource::Native,
                 &profile
                     .tools
-                    .into_iter()
-                    .filter_map(|(tool, enabled)| enabled.then(|| tool))
+                    .iter()
+                    .filter_map(|(tool, enabled)| enabled.then(|| tool.clone()))
                     .collect::<Vec<_>>(),
                 cx,
             );
@@ -530,32 +511,32 @@ impl ThreadStore {
                 });
             }
             // Enable all the tools from all context servers, but disable the ones that are explicitly disabled
-            for (context_server_id, preset) in profile.context_servers {
+            for (context_server_id, preset) in &profile.context_servers {
                 self.tools.update(cx, |tools, cx| {
                     tools.disable(
                         ToolSource::ContextServer {
-                            id: context_server_id.into(),
+                            id: context_server_id.clone().into(),
                         },
                         &preset
                             .tools
-                            .into_iter()
-                            .filter_map(|(tool, enabled)| (!enabled).then(|| tool))
+                            .iter()
+                            .filter_map(|(tool, enabled)| (!enabled).then(|| tool.clone()))
                             .collect::<Vec<_>>(),
                         cx,
                     )
                 })
             }
         } else {
-            for (context_server_id, preset) in profile.context_servers {
+            for (context_server_id, preset) in &profile.context_servers {
                 self.tools.update(cx, |tools, cx| {
                     tools.enable(
                         ToolSource::ContextServer {
-                            id: context_server_id.into(),
+                            id: context_server_id.clone().into(),
                         },
                         &preset
                             .tools
-                            .into_iter()
-                            .filter_map(|(tool, enabled)| enabled.then(|| tool))
+                            .iter()
+                            .filter_map(|(tool, enabled)| enabled.then(|| tool.clone()))
                             .collect::<Vec<_>>(),
                         cx,
                     )
@@ -794,7 +775,7 @@ pub struct SerializedToolUse {
 pub struct SerializedToolResult {
     pub tool_use_id: LanguageModelToolUseId,
     pub is_error: bool,
-    pub content: LanguageModelToolResultContent,
+    pub content: Arc<str>,
     pub output: Option<serde_json::Value>,
 }
 

crates/agent/src/tool_use.rs

@@ -1,16 +1,14 @@
 use std::sync::Arc;
 
 use anyhow::Result;
-use assistant_tool::{
-    AnyToolCard, Tool, ToolResultContent, ToolResultOutput, ToolUseStatus, ToolWorkingSet,
-};
+use assistant_tool::{AnyToolCard, Tool, ToolResultOutput, ToolUseStatus, ToolWorkingSet};
 use collections::HashMap;
 use futures::FutureExt as _;
 use futures::future::Shared;
 use gpui::{App, Entity, SharedString, Task};
 use language_model::{
     ConfiguredModel, LanguageModel, LanguageModelRequest, LanguageModelToolResult,
-    LanguageModelToolResultContent, LanguageModelToolUse, LanguageModelToolUseId, Role,
+    LanguageModelToolUse, LanguageModelToolUseId, Role,
 };
 use project::Project;
 use ui::{IconName, Window};
@@ -54,19 +52,15 @@ impl ToolUseState {
     /// Constructs a [`ToolUseState`] from the given list of [`SerializedMessage`]s.
     ///
     /// Accepts a function to filter the tools that should be used to populate the state.
-    ///
-    /// If `window` is `None` (e.g., when in headless mode or when running evals),
-    /// tool cards won't be deserialized
     pub fn from_serialized_messages(
         tools: Entity<ToolWorkingSet>,
         messages: &[SerializedMessage],
         project: Entity<Project>,
-        window: Option<&mut Window>, // None in headless mode
+        window: &mut Window,
         cx: &mut App,
     ) -> Self {
         let mut this = Self::new(tools);
         let mut tool_names_by_id = HashMap::default();
-        let mut window = window;
 
         for message in messages {
             match message.role {
@@ -111,17 +105,12 @@ impl ToolUseState {
                                 },
                             );
 
-                            if let Some(window) = &mut window {
-                                if let Some(tool) = this.tools.read(cx).tool(tool_use, cx) {
-                                    if let Some(output) = tool_result.output.clone() {
-                                        if let Some(card) = tool.deserialize_card(
-                                            output,
-                                            project.clone(),
-                                            window,
-                                            cx,
-                                        ) {
-                                            this.tool_result_cards.insert(tool_use_id, card);
-                                        }
+                            if let Some(tool) = this.tools.read(cx).tool(tool_use, cx) {
+                                if let Some(output) = tool_result.output.clone() {
+                                    if let Some(card) =
+                                        tool.deserialize_card(output, project.clone(), window, cx)
+                                    {
+                                        this.tool_result_cards.insert(tool_use_id, card);
                                     }
                                 }
                             }
@@ -176,16 +165,10 @@ impl ToolUseState {
 
             let status = (|| {
                 if let Some(tool_result) = tool_result {
-                    let content = tool_result
-                        .content
-                        .to_str()
-                        .map(|str| str.to_owned().into())
-                        .unwrap_or_default();
-
                     return if tool_result.is_error {
-                        ToolUseStatus::Error(content)
+                        ToolUseStatus::Error(tool_result.content.clone().into())
                     } else {
-                        ToolUseStatus::Finished(content)
+                        ToolUseStatus::Finished(tool_result.content.clone().into())
                     };
                 }
 
@@ -416,44 +399,21 @@ impl ToolUseState {
                 let tool_result = output.content;
                 const BYTES_PER_TOKEN_ESTIMATE: usize = 3;
 
-                let old_use = self.pending_tool_uses_by_id.remove(&tool_use_id);
-
-                // Protect from overly large output
+                // Protect from clearly large output
                 let tool_output_limit = configured_model
                     .map(|model| model.model.max_token_count() * BYTES_PER_TOKEN_ESTIMATE)
                     .unwrap_or(usize::MAX);
 
-                let content = match tool_result {
-                    ToolResultContent::Text(text) => {
-                        let truncated = truncate_lines_to_byte_limit(&text, tool_output_limit);
+                let tool_result = if tool_result.len() <= tool_output_limit {
+                    tool_result
+                } else {
+                    let truncated = truncate_lines_to_byte_limit(&tool_result, tool_output_limit);
 
-                        LanguageModelToolResultContent::Text(
-                            format!(
-                                "Tool result too long. The first {} bytes:\n\n{}",
-                                truncated.len(),
-                                truncated
-                            )
-                            .into(),
-                        )
-                    }
-                    ToolResultContent::Image(language_model_image) => {
-                        if language_model_image.estimate_tokens() < tool_output_limit {
-                            LanguageModelToolResultContent::Image(language_model_image)
-                        } else {
-                            self.tool_results.insert(
-                                tool_use_id.clone(),
-                                LanguageModelToolResult {
-                                    tool_use_id: tool_use_id.clone(),
-                                    tool_name,
-                                    content: "Tool responded with an image that would exceeded the remaining tokens".into(),
-                                    is_error: true,
-                                    output: None,
-                                },
-                            );
-
-                            return old_use;
-                        }
-                    }
+                    format!(
+                        "Tool result too long. The first {} bytes:\n\n{}",
+                        truncated.len(),
+                        truncated
+                    )
                 };
 
                 self.tool_results.insert(
@@ -461,13 +421,12 @@ impl ToolUseState {
                     LanguageModelToolResult {
                         tool_use_id: tool_use_id.clone(),
                         tool_name,
-                        content,
+                        content: tool_result.into(),
                         is_error: false,
                         output: output.output,
                     },
                 );
-
-                old_use
+                self.pending_tool_uses_by_id.remove(&tool_use_id)
             }
             Err(err) => {
                 self.tool_results.insert(
@@ -475,7 +434,7 @@ impl ToolUseState {
                     LanguageModelToolResult {
                         tool_use_id: tool_use_id.clone(),
                         tool_name,
-                        content: LanguageModelToolResultContent::Text(err.to_string().into()),
+                        content: err.to_string().into(),
                         is_error: true,
                         output: None,
                     },

crates/anthropic/src/anthropic.rs

@@ -534,26 +534,12 @@ pub enum RequestContent {
     ToolResult {
         tool_use_id: String,
         is_error: bool,
-        content: ToolResultContent,
+        content: String,
         #[serde(skip_serializing_if = "Option::is_none")]
         cache_control: Option<CacheControl>,
     },
 }
 
-#[derive(Debug, Serialize, Deserialize)]
-#[serde(untagged)]
-pub enum ToolResultContent {
-    Plain(String),
-    Multipart(Vec<ToolResultPart>),
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-#[serde(tag = "type", rename_all = "lowercase")]
-pub enum ToolResultPart {
-    Text { text: String },
-    Image { source: ImageSource },
-}
-
 #[derive(Debug, Serialize, Deserialize)]
 #[serde(tag = "type")]
 pub enum ResponseContent {

crates/assistant_context_editor/src/context.rs

@@ -21,8 +21,8 @@ use language::{AnchorRangeExt, Bias, Buffer, LanguageRegistry, OffsetRangeExt, P
 use language_model::{
     LanguageModel, LanguageModelCacheConfiguration, LanguageModelCompletionEvent,
     LanguageModelImage, LanguageModelRegistry, LanguageModelRequest, LanguageModelRequestMessage,
-    LanguageModelToolUseId, MessageContent, PaymentRequiredError, Role, StopReason,
-    report_assistant_event,
+    LanguageModelToolUseId, MaxMonthlySpendReachedError, MessageContent, PaymentRequiredError,
+    Role, StopReason, report_assistant_event,
 };
 use open_ai::Model as OpenAiModel;
 use paths::contexts_dir;
@@ -447,6 +447,7 @@ impl ContextOperation {
 pub enum ContextEvent {
     ShowAssistError(SharedString),
     ShowPaymentRequiredError,
+    ShowMaxMonthlySpendReachedError,
     MessagesEdited,
     SummaryChanged,
     SummaryGenerated,
@@ -2154,6 +2155,12 @@ impl AssistantContext {
                                 metadata.status = MessageStatus::Canceled;
                             });
                             Some(error.to_string())
+                        } else if error.is::<MaxMonthlySpendReachedError>() {
+                            cx.emit(ContextEvent::ShowMaxMonthlySpendReachedError);
+                            this.update_metadata(assistant_message_id, cx, |metadata| {
+                                metadata.status = MessageStatus::Canceled;
+                            });
+                            Some(error.to_string())
                         } else {
                             let error_message = error
                                 .chain()

crates/assistant_context_editor/src/context_editor.rs

@@ -114,6 +114,7 @@ type MessageHeader = MessageMetadata;
 #[derive(Clone)]
 enum AssistError {
     PaymentRequired,
+    MaxMonthlySpendReached,
     Message(SharedString),
 }
 
@@ -731,6 +732,9 @@ impl ContextEditor {
             ContextEvent::ShowPaymentRequiredError => {
                 self.last_error = Some(AssistError::PaymentRequired);
             }
+            ContextEvent::ShowMaxMonthlySpendReachedError => {
+                self.last_error = Some(AssistError::MaxMonthlySpendReached);
+            }
         }
     }
 
@@ -1590,7 +1594,7 @@ impl ContextEditor {
         &mut self,
         cx: &mut Context<Self>,
     ) -> (String, CopyMetadata, Vec<text::Selection<usize>>) {
-        let (mut selection, creases) = self.editor.update(cx, |editor, cx| {
+        let (selection, creases) = self.editor.update(cx, |editor, cx| {
             let mut selection = editor.selections.newest_adjusted(cx);
             let snapshot = editor.buffer().read(cx).snapshot(cx);
 
@@ -1648,18 +1652,7 @@ impl ContextEditor {
             } else if message.offset_range.end >= selection.range().start {
                 let range = cmp::max(message.offset_range.start, selection.range().start)
                     ..cmp::min(message.offset_range.end, selection.range().end);
-                if range.is_empty() {
-                    let snapshot = context.buffer().read(cx).snapshot();
-                    let point = snapshot.offset_to_point(range.start);
-                    selection.start = snapshot.point_to_offset(Point::new(point.row, 0));
-                    selection.end = snapshot.point_to_offset(cmp::min(
-                        Point::new(point.row + 1, 0),
-                        snapshot.max_point(),
-                    ));
-                    for chunk in context.buffer().read(cx).text_for_range(selection.range()) {
-                        text.push_str(chunk);
-                    }
-                } else {
+                if !range.is_empty() {
                     for chunk in context.buffer().read(cx).text_for_range(range) {
                         text.push_str(chunk);
                     }
@@ -2114,6 +2107,9 @@ impl ContextEditor {
                 .occlude()
                 .child(match last_error {
                     AssistError::PaymentRequired => self.render_payment_required_error(cx),
+                    AssistError::MaxMonthlySpendReached => {
+                        self.render_max_monthly_spend_reached_error(cx)
+                    }
                     AssistError::Message(error_message) => {
                         self.render_assist_error(error_message, cx)
                     }
@@ -2162,6 +2158,48 @@ impl ContextEditor {
             .into_any()
     }
 
+    fn render_max_monthly_spend_reached_error(&self, cx: &mut Context<Self>) -> AnyElement {
+        const ERROR_MESSAGE: &str = "You have reached your maximum monthly spend. Increase your spend limit to continue using Zed LLMs.";
+
+        v_flex()
+            .gap_0p5()
+            .child(
+                h_flex()
+                    .gap_1p5()
+                    .items_center()
+                    .child(Icon::new(IconName::XCircle).color(Color::Error))
+                    .child(Label::new("Max Monthly Spend Reached").weight(FontWeight::MEDIUM)),
+            )
+            .child(
+                div()
+                    .id("error-message")
+                    .max_h_24()
+                    .overflow_y_scroll()
+                    .child(Label::new(ERROR_MESSAGE)),
+            )
+            .child(
+                h_flex()
+                    .justify_end()
+                    .mt_1()
+                    .child(
+                        Button::new("subscribe", "Update Monthly Spend Limit").on_click(
+                            cx.listener(|this, _, _window, cx| {
+                                this.last_error = None;
+                                cx.open_url(&zed_urls::account_url(cx));
+                                cx.notify();
+                            }),
+                        ),
+                    )
+                    .child(Button::new("dismiss", "Dismiss").on_click(cx.listener(
+                        |this, _, _window, cx| {
+                            this.last_error = None;
+                            cx.notify();
+                        },
+                    ))),
+            )
+            .into_any()
+    }
+
     fn render_assist_error(
         &self,
         error_message: &SharedString,
@@ -3213,77 +3251,9 @@ pub fn make_lsp_adapter_delegate(
 #[cfg(test)]
 mod tests {
     use super::*;
-    use fs::FakeFs;
-    use gpui::{App, TestAppContext, VisualTestContext};
-    use language::{Buffer, LanguageRegistry};
-    use prompt_store::PromptBuilder;
+    use gpui::App;
+    use language::Buffer;
     use unindent::Unindent;
-    use util::path;
-
-    #[gpui::test]
-    async fn test_copy_paste_no_selection(cx: &mut TestAppContext) {
-        cx.update(init_test);
-
-        let fs = FakeFs::new(cx.executor());
-        let registry = Arc::new(LanguageRegistry::test(cx.executor()));
-        let prompt_builder = Arc::new(PromptBuilder::new(None).unwrap());
-        let context = cx.new(|cx| {
-            AssistantContext::local(
-                registry,
-                None,
-                None,
-                prompt_builder.clone(),
-                Arc::new(SlashCommandWorkingSet::default()),
-                cx,
-            )
-        });
-        let project = Project::test(fs.clone(), [path!("/test").as_ref()], cx).await;
-        let window = cx.add_window(|window, cx| Workspace::test_new(project.clone(), window, cx));
-        let workspace = window.root(cx).unwrap();
-        let cx = &mut VisualTestContext::from_window(*window, cx);
-
-        let context_editor = window
-            .update(cx, |_, window, cx| {
-                cx.new(|cx| {
-                    ContextEditor::for_context(
-                        context,
-                        fs,
-                        workspace.downgrade(),
-                        project,
-                        None,
-                        window,
-                        cx,
-                    )
-                })
-            })
-            .unwrap();
-
-        context_editor.update_in(cx, |context_editor, window, cx| {
-            context_editor.editor.update(cx, |editor, cx| {
-                editor.set_text("abc\ndef\nghi", window, cx);
-                editor.move_to_beginning(&Default::default(), window, cx);
-            })
-        });
-
-        context_editor.update_in(cx, |context_editor, window, cx| {
-            context_editor.editor.update(cx, |editor, cx| {
-                editor.copy(&Default::default(), window, cx);
-                editor.paste(&Default::default(), window, cx);
-
-                assert_eq!(editor.text(cx), "abc\nabc\ndef\nghi");
-            })
-        });
-
-        context_editor.update_in(cx, |context_editor, window, cx| {
-            context_editor.editor.update(cx, |editor, cx| {
-                editor.cut(&Default::default(), window, cx);
-                assert_eq!(editor.text(cx), "abc\ndef\nghi");
-
-                editor.paste(&Default::default(), window, cx);
-                assert_eq!(editor.text(cx), "abc\nabc\ndef\nghi");
-            })
-        });
-    }
 
     #[gpui::test]
     fn test_find_code_blocks(cx: &mut App) {
@@ -3358,17 +3328,4 @@ mod tests {
             assert_eq!(range, expected, "unexpected result on row {:?}", row);
         }
     }
-
-    fn init_test(cx: &mut App) {
-        let settings_store = SettingsStore::test(cx);
-        prompt_store::init(cx);
-        LanguageModelRegistry::test(cx);
-        cx.set_global(settings_store);
-        language::init(cx);
-        assistant_settings::init(cx);
-        Project::init_settings(cx);
-        theme::init(theme::LoadThemes::JustBase, cx);
-        workspace::init_settings(cx);
-        editor::init_settings(cx);
-    }
 }

crates/assistant_context_editor/src/slash_command.rs

@@ -278,8 +278,8 @@ impl CompletionProvider for SlashCommandCompletionProvider {
                         buffer.anchor_after(Point::new(position.row, first_arg_start.start as u32));
                     let arguments = call
                         .arguments
-                        .into_iter()
-                        .filter_map(|argument| Some(line.get(argument)?.to_string()))
+                        .iter()
+                        .filter_map(|argument| Some(line.get(argument.clone())?.to_string()))
                         .collect::<Vec<_>>();
                     let argument_range = first_arg_start..buffer_position;
                     (

crates/assistant_settings/src/assistant_settings.rs

@@ -41,7 +41,6 @@ pub enum NotifyWhenAgentWaiting {
 
 #[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
 #[serde(tag = "name", rename_all = "snake_case")]
-#[schemars(deny_unknown_fields)]
 pub enum AssistantProviderContentV1 {
     #[serde(rename = "zed.dev")]
     ZedDotDev { default_model: Option<CloudModel> },
@@ -544,7 +543,6 @@ impl AssistantSettingsContent {
 
 #[derive(Clone, Serialize, Deserialize, JsonSchema, Debug)]
 #[serde(tag = "version")]
-#[schemars(deny_unknown_fields)]
 pub enum VersionedAssistantSettingsContent {
     #[serde(rename = "1")]
     V1(AssistantSettingsContentV1),
@@ -578,7 +576,6 @@ impl Default for VersionedAssistantSettingsContent {
 }
 
 #[derive(Clone, Serialize, Deserialize, JsonSchema, Debug, Default)]
-#[schemars(deny_unknown_fields)]
 pub struct AssistantSettingsContentV2 {
     /// Whether the Assistant is enabled.
     ///
@@ -737,7 +734,6 @@ pub struct ContextServerPresetContent {
 }
 
 #[derive(Clone, Serialize, Deserialize, JsonSchema, Debug)]
-#[schemars(deny_unknown_fields)]
 pub struct AssistantSettingsContentV1 {
     /// Whether the Assistant is enabled.
     ///
@@ -767,7 +763,6 @@ pub struct AssistantSettingsContentV1 {
 }
 
 #[derive(Clone, Serialize, Deserialize, JsonSchema, Debug)]
-#[schemars(deny_unknown_fields)]
 pub struct LegacyAssistantSettingsContent {
     /// Whether to show the assistant panel button in the status bar.
     ///

crates/assistant_tool/src/assistant_tool.rs

@@ -19,7 +19,6 @@ use gpui::Window;
 use gpui::{App, Entity, SharedString, Task, WeakEntity};
 use icons::IconName;
 use language_model::LanguageModel;
-use language_model::LanguageModelImage;
 use language_model::LanguageModelRequest;
 use language_model::LanguageModelToolSchemaFormat;
 use project::Project;
@@ -66,50 +65,21 @@ impl ToolUseStatus {
 
 #[derive(Debug)]
 pub struct ToolResultOutput {
-    pub content: ToolResultContent,
+    pub content: String,
     pub output: Option<serde_json::Value>,
 }
 
-#[derive(Debug, PartialEq, Eq)]
-pub enum ToolResultContent {
-    Text(String),
-    Image(LanguageModelImage),
-}
-
-impl ToolResultContent {
-    pub fn len(&self) -> usize {
-        match self {
-            ToolResultContent::Text(str) => str.len(),
-            ToolResultContent::Image(image) => image.len(),
-        }
-    }
-
-    pub fn is_empty(&self) -> bool {
-        match self {
-            ToolResultContent::Text(str) => str.is_empty(),
-            ToolResultContent::Image(image) => image.is_empty(),
-        }
-    }
-
-    pub fn as_str(&self) -> Option<&str> {
-        match self {
-            ToolResultContent::Text(str) => Some(str),
-            ToolResultContent::Image(_) => None,
-        }
-    }
-}
-
 impl From<String> for ToolResultOutput {
     fn from(value: String) -> Self {
         ToolResultOutput {
-            content: ToolResultContent::Text(value),
+            content: value,
             output: None,
         }
     }
 }
 
 impl Deref for ToolResultOutput {
-    type Target = ToolResultContent;
+    type Target = String;
 
     fn deref(&self) -> &Self::Target {
         &self.content

crates/assistant_tools/src/assistant_tools.rs

@@ -42,7 +42,7 @@ use crate::list_directory_tool::ListDirectoryTool;
 use crate::now_tool::NowTool;
 use crate::thinking_tool::ThinkingTool;
 
-pub use edit_file_tool::{EditFileMode, EditFileToolInput};
+pub use edit_file_tool::EditFileToolInput;
 pub use find_path_tool::FindPathToolInput;
 pub use open_tool::OpenTool;
 pub use read_file_tool::{ReadFileTool, ReadFileToolInput};

crates/assistant_tools/src/edit_agent/evals.rs

@@ -1,9 +1,5 @@
 use super::*;
-use crate::{
-    ReadFileToolInput,
-    edit_file_tool::{EditFileMode, EditFileToolInput},
-    grep_tool::GrepToolInput,
-};
+use crate::{ReadFileToolInput, edit_file_tool::EditFileToolInput, grep_tool::GrepToolInput};
 use Role::*;
 use anyhow::anyhow;
 use assistant_tool::ToolRegistry;
@@ -14,8 +10,8 @@ use futures::{FutureExt, future::LocalBoxFuture};
 use gpui::{AppContext, TestAppContext};
 use indoc::{formatdoc, indoc};
 use language_model::{
-    LanguageModelRegistry, LanguageModelRequestTool, LanguageModelToolResult,
-    LanguageModelToolResultContent, LanguageModelToolUse, LanguageModelToolUseId,
+    LanguageModelRegistry, LanguageModelRequestTool, LanguageModelToolResult, LanguageModelToolUse,
+    LanguageModelToolUseId,
 };
 use project::Project;
 use rand::prelude::*;
@@ -75,7 +71,7 @@ fn eval_extract_handle_command_output() {
                         EditFileToolInput {
                             display_description: edit_description.into(),
                             path: input_file_path.into(),
-                            mode: EditFileMode::Edit,
+                            create_or_overwrite: false,
                         },
                     )],
                 ),
@@ -131,7 +127,7 @@ fn eval_delete_run_git_blame() {
                         EditFileToolInput {
                             display_description: edit_description.into(),
                             path: input_file_path.into(),
-                            mode: EditFileMode::Edit,
+                            create_or_overwrite: false,
                         },
                     )],
                 ),
@@ -186,7 +182,7 @@ fn eval_translate_doc_comments() {
                         EditFileToolInput {
                             display_description: edit_description.into(),
                             path: input_file_path.into(),
-                            mode: EditFileMode::Edit,
+                            create_or_overwrite: false,
                         },
                     )],
                 ),
@@ -301,7 +297,7 @@ fn eval_use_wasi_sdk_in_compile_parser_to_wasm() {
                         EditFileToolInput {
                             display_description: edit_description.into(),
                             path: input_file_path.into(),
-                            mode: EditFileMode::Edit,
+                            create_or_overwrite: false,
                         },
                     )],
                 ),
@@ -376,7 +372,7 @@ fn eval_disable_cursor_blinking() {
                         EditFileToolInput {
                             display_description: edit_description.into(),
                             path: input_file_path.into(),
-                            mode: EditFileMode::Edit,
+                            create_or_overwrite: false,
                         },
                     )],
                 ),
@@ -570,7 +566,7 @@ fn eval_from_pixels_constructor() {
                         EditFileToolInput {
                             display_description: edit_description.into(),
                             path: input_file_path.into(),
-                            mode: EditFileMode::Edit,
+                            create_or_overwrite: false,
                         },
                     )],
                 ),
@@ -647,7 +643,7 @@ fn eval_zode() {
                             EditFileToolInput {
                                 display_description: edit_description.into(),
                                 path: input_file_path.into(),
-                                mode: EditFileMode::Create,
+                                create_or_overwrite: true,
                             },
                         ),
                     ],
@@ -892,7 +888,7 @@ fn eval_add_overwrite_test() {
                             EditFileToolInput {
                                 display_description: edit_description.into(),
                                 path: input_file_path.into(),
-                                mode: EditFileMode::Edit,
+                                create_or_overwrite: false,
                             },
                         ),
                     ],
@@ -955,7 +951,7 @@ fn tool_result(
         tool_use_id: LanguageModelToolUseId::from(id.into()),
         tool_name: name.into(),
         is_error: false,
-        content: LanguageModelToolResultContent::Text(result.into()),
+        content: result.into(),
         output: None,
     })
 }

crates/assistant_tools/src/edit_file_tool.rs

@@ -5,8 +5,7 @@ use crate::{
 };
 use anyhow::{Result, anyhow};
 use assistant_tool::{
-    ActionLog, AnyToolCard, Tool, ToolCard, ToolResult, ToolResultContent, ToolResultOutput,
-    ToolUseStatus,
+    ActionLog, AnyToolCard, Tool, ToolCard, ToolResult, ToolResultOutput, ToolUseStatus,
 };
 use buffer_diff::{BufferDiff, BufferDiffSnapshot};
 use editor::{Editor, EditorMode, MultiBuffer, PathKey};
@@ -76,22 +75,12 @@ pub struct EditFileToolInput {
     /// </example>
     pub path: PathBuf,
 
-    /// The mode of operation on the file. Possible values:
-    /// - 'edit': Make granular edits to an existing file.
-    /// - 'create': Create a new file if it doesn't exist.
-    /// - 'overwrite': Replace the entire contents of an existing file.
+    /// If true, this tool will recreate the file from scratch.
+    /// If false, this tool will produce granular edits to an existing file.
     ///
-    /// When a file already exists or you just created it, prefer editing
+    /// When a file already exists or you just created it, always prefer editing
     /// it as opposed to recreating it from scratch.
-    pub mode: EditFileMode,
-}
-
-#[derive(Debug, Serialize, Deserialize, JsonSchema)]
-#[serde(rename_all = "lowercase")]
-pub enum EditFileMode {
-    Edit,
-    Create,
-    Overwrite,
+    pub create_or_overwrite: bool,
 }
 
 #[derive(Debug, Serialize, Deserialize, JsonSchema)]
@@ -205,11 +194,7 @@ impl Tool for EditFileTool {
                     .as_ref()
                     .map_or(false, |file| file.disk_state().exists())
             })?;
-            let create_or_overwrite = match input.mode {
-                EditFileMode::Create | EditFileMode::Overwrite => true,
-                _ => false,
-            };
-            if !create_or_overwrite && !exists {
+            if !input.create_or_overwrite && !exists {
                 return Err(anyhow!("{} not found", input.path.display()));
             }
 
@@ -221,7 +206,7 @@ impl Tool for EditFileTool {
                 })
                 .await;
 
-            let (output, mut events) = if create_or_overwrite {
+            let (output, mut events) = if input.create_or_overwrite {
                 edit_agent.overwrite(
                     buffer.clone(),
                     input.display_description.clone(),
@@ -307,10 +292,7 @@ impl Tool for EditFileTool {
                 }
             } else {
                 Ok(ToolResultOutput {
-                    content: ToolResultContent::Text(format!(
-                        "Edited {}:\n\n```diff\n{}\n```",
-                        input_path, diff
-                    )),
+                    content: format!("Edited {}:\n\n```diff\n{}\n```", input_path, diff),
                     output: serde_json::to_value(output).ok(),
                 })
             }
@@ -890,7 +872,7 @@ mod tests {
                 let input = serde_json::to_value(EditFileToolInput {
                     display_description: "Some edit".into(),
                     path: "root/nonexistent_file.txt".into(),
-                    mode: EditFileMode::Edit,
+                    create_or_overwrite: false,
                 })
                 .unwrap();
                 Arc::new(EditFileTool)

crates/assistant_tools/src/find_path_tool.rs

@@ -1,8 +1,6 @@
 use crate::{schema::json_schema_for, ui::ToolCallCardHeader};
 use anyhow::{Result, anyhow};
-use assistant_tool::{
-    ActionLog, Tool, ToolCard, ToolResult, ToolResultContent, ToolResultOutput, ToolUseStatus,
-};
+use assistant_tool::{ActionLog, Tool, ToolCard, ToolResult, ToolUseStatus};
 use editor::Editor;
 use futures::channel::oneshot::{self, Receiver};
 use gpui::{
@@ -40,12 +38,6 @@ pub struct FindPathToolInput {
     pub offset: usize,
 }
 
-#[derive(Debug, Serialize, Deserialize)]
-struct FindPathToolOutput {
-    glob: String,
-    paths: Vec<PathBuf>,
-}
-
 const RESULTS_PER_PAGE: usize = 50;
 
 pub struct FindPathTool;
@@ -119,18 +111,10 @@ impl Tool for FindPathTool {
                     )
                     .unwrap();
                 }
-                let output = FindPathToolOutput {
-                    glob,
-                    paths: matches.clone(),
-                };
-
                 for mat in matches.into_iter().skip(offset).take(RESULTS_PER_PAGE) {
                     write!(&mut message, "\n{}", mat.display()).unwrap();
                 }
-                Ok(ToolResultOutput {
-                    content: ToolResultContent::Text(message),
-                    output: Some(serde_json::to_value(output)?),
-                })
+                Ok(message.into())
             }
         });
 
@@ -139,18 +123,6 @@ impl Tool for FindPathTool {
             card: Some(card.into()),
         }
     }
-
-    fn deserialize_card(
-        self: Arc<Self>,
-        output: serde_json::Value,
-        _project: Entity<Project>,
-        _window: &mut Window,
-        cx: &mut App,
-    ) -> Option<assistant_tool::AnyToolCard> {
-        let output = serde_json::from_value::<FindPathToolOutput>(output).ok()?;
-        let card = cx.new(|_| FindPathToolCard::from_output(output));
-        Some(card.into())
-    }
 }
 
 fn search_paths(glob: &str, project: Entity<Project>, cx: &mut App) -> Task<Result<Vec<PathBuf>>> {
@@ -208,15 +180,6 @@ impl FindPathToolCard {
             _receiver_task: Some(_receiver_task),
         }
     }
-
-    fn from_output(output: FindPathToolOutput) -> Self {
-        Self {
-            glob: output.glob,
-            paths: output.paths,
-            expanded: false,
-            _receiver_task: None,
-        }
-    }
 }
 
 impl ToolCard for FindPathToolCard {

crates/assistant_tools/src/grep_tool.rs

@@ -752,9 +752,9 @@ mod tests {
         match task.output.await {
             Ok(result) => {
                 if cfg!(windows) {
-                    result.content.as_str().unwrap().replace("root\\", "root/")
+                    result.content.replace("root\\", "root/")
                 } else {
-                    result.content.as_str().unwrap().to_string()
+                    result.content
                 }
             }
             Err(e) => panic!("Failed to run grep tool: {}", e),

crates/assistant_tools/src/read_file_tool.rs

@@ -1,17 +1,13 @@
 use crate::schema::json_schema_for;
 use anyhow::{Result, anyhow};
+use assistant_tool::outline;
 use assistant_tool::{ActionLog, Tool, ToolResult};
-use assistant_tool::{ToolResultContent, outline};
 use gpui::{AnyWindowHandle, App, Entity, Task};
-use project::{ImageItem, image_store};
 
-use assistant_tool::ToolResultOutput;
 use indoc::formatdoc;
 use itertools::Itertools;
 use language::{Anchor, Point};
-use language_model::{
-    LanguageModel, LanguageModelImage, LanguageModelRequest, LanguageModelToolSchemaFormat,
-};
+use language_model::{LanguageModel, LanguageModelRequest, LanguageModelToolSchemaFormat};
 use project::{AgentLocation, Project};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
@@ -90,7 +86,7 @@ impl Tool for ReadFileTool {
         _request: Arc<LanguageModelRequest>,
         project: Entity<Project>,
         action_log: Entity<ActionLog>,
-        model: Arc<dyn LanguageModel>,
+        _model: Arc<dyn LanguageModel>,
         _window: Option<AnyWindowHandle>,
         cx: &mut App,
     ) -> ToolResult {
@@ -104,42 +100,6 @@ impl Tool for ReadFileTool {
         };
 
         let file_path = input.path.clone();
-
-        if image_store::is_image_file(&project, &project_path, cx) {
-            if !model.supports_images() {
-                return Task::ready(Err(anyhow!(
-                    "Attempted to read an image, but Zed doesn't currently sending images to {}.",
-                    model.name().0
-                )))
-                .into();
-            }
-
-            let task = cx.spawn(async move |cx| -> Result<ToolResultOutput> {
-                let image_entity: Entity<ImageItem> = cx
-                    .update(|cx| {
-                        project.update(cx, |project, cx| {
-                            project.open_image(project_path.clone(), cx)
-                        })
-                    })?
-                    .await?;
-
-                let image =
-                    image_entity.read_with(cx, |image_item, _| Arc::clone(&image_item.image))?;
-
-                let language_model_image = cx
-                    .update(|cx| LanguageModelImage::from_image(image, cx))?
-                    .await
-                    .ok_or_else(|| anyhow!("Failed to process image"))?;
-
-                Ok(ToolResultOutput {
-                    content: ToolResultContent::Image(language_model_image),
-                    output: None,
-                })
-            });
-
-            return task.into();
-        }
-
         cx.spawn(async move |cx| {
             let buffer = cx
                 .update(|cx| {
@@ -322,10 +282,7 @@ mod test {
                     .output
             })
             .await;
-        assert_eq!(
-            result.unwrap().content.as_str(),
-            Some("This is a small file content")
-        );
+        assert_eq!(result.unwrap().content, "This is a small file content");
     }
 
     #[gpui::test]
@@ -365,7 +322,6 @@ mod test {
             })
             .await;
         let content = result.unwrap();
-        let content = content.as_str().unwrap();
         assert_eq!(
             content.lines().skip(4).take(6).collect::<Vec<_>>(),
             vec![
@@ -409,8 +365,6 @@ mod test {
             .collect::<Vec<_>>();
         pretty_assertions::assert_eq!(
             content
-                .as_str()
-                .unwrap()
                 .lines()
                 .skip(4)
                 .take(expected_content.len())
@@ -454,10 +408,7 @@ mod test {
                     .output
             })
             .await;
-        assert_eq!(
-            result.unwrap().content.as_str(),
-            Some("Line 2\nLine 3\nLine 4")
-        );
+        assert_eq!(result.unwrap().content, "Line 2\nLine 3\nLine 4");
     }
 
     #[gpui::test]
@@ -497,7 +448,7 @@ mod test {
                     .output
             })
             .await;
-        assert_eq!(result.unwrap().content.as_str(), Some("Line 1\nLine 2"));
+        assert_eq!(result.unwrap().content, "Line 1\nLine 2");
 
         // end_line of 0 should result in at least 1 line
         let result = cx
@@ -520,7 +471,7 @@ mod test {
                     .output
             })
             .await;
-        assert_eq!(result.unwrap().content.as_str(), Some("Line 1"));
+        assert_eq!(result.unwrap().content, "Line 1");
 
         // when start_line > end_line, should still return at least 1 line
         let result = cx
@@ -543,7 +494,7 @@ mod test {
                     .output
             })
             .await;
-        assert_eq!(result.unwrap().content.as_str(), Some("Line 3"));
+        assert_eq!(result.unwrap().content, "Line 3");
     }
 
     fn init_test(cx: &mut TestAppContext) {

crates/assistant_tools/src/terminal_tool.rs

@@ -1,5 +1,5 @@
 use crate::schema::json_schema_for;
-use anyhow::{Context as _, Result, anyhow};
+use anyhow::{Context as _, Result, anyhow, bail};
 use assistant_tool::{ActionLog, Tool, ToolCard, ToolResult, ToolUseStatus};
 use futures::{FutureExt as _, future::Shared};
 use gpui::{
@@ -125,24 +125,14 @@ impl Tool for TerminalTool {
             Err(err) => return Task::ready(Err(anyhow!(err))).into(),
         };
 
-        let working_dir = match working_dir(&input, &project, cx) {
+        let input_path = Path::new(&input.cd);
+        let working_dir = match working_dir(&input, &project, input_path, cx) {
             Ok(dir) => dir,
             Err(err) => return Task::ready(Err(err)).into(),
         };
         let program = self.determine_shell.clone();
-        let command = if cfg!(windows) {
-            format!("$null | & {{{}}}", input.command.replace("\"", "'"))
-        } else if let Some(cwd) = working_dir
-            .as_ref()
-            .and_then(|cwd| cwd.as_os_str().to_str())
-        {
-            // Make sure once we're *inside* the shell, we cd into `cwd`
-            format!("(cd {cwd}; {}) </dev/null", input.command)
-        } else {
-            format!("({}) </dev/null", input.command)
-        };
-        let args = vec!["-c".into(), command];
-
+        let command = format!("({}) </dev/null", input.command);
+        let args = vec!["-c".into(), command.clone()];
         let cwd = working_dir.clone();
         let env = match &working_dir {
             Some(dir) => project.update(cx, |project, cx| {
@@ -325,13 +315,19 @@ fn process_content(
     } else {
         content
     };
-    let content = content.trim();
-    let is_empty = content.is_empty();
-    let content = format!("```\n{content}\n```");
+    let is_empty = content.trim().is_empty();
+
+    let content = format!(
+        "```\n{}{}```",
+        content,
+        if content.ends_with('\n') { "" } else { "\n" }
+    );
+
     let content = if should_truncate {
         format!(
-            "Command output too long. The first {} bytes:\n\n{content}",
+            "Command output too long. The first {} bytes:\n\n{}",
             content.len(),
+            content,
         )
     } else {
         content
@@ -371,47 +367,42 @@ fn process_content(
 fn working_dir(
     input: &TerminalToolInput,
     project: &Entity<Project>,
+    input_path: &Path,
     cx: &mut App,
 ) -> Result<Option<PathBuf>> {
     let project = project.read(cx);
-    let cd = &input.cd;
 
-    if cd == "." || cd == "" {
-        // Accept "." or "" as meaning "the one worktree" if we only have one worktree.
+    if input.cd == "." {
+        // Accept "." as meaning "the one worktree" if we only have one worktree.
         let mut worktrees = project.worktrees(cx);
 
         match worktrees.next() {
             Some(worktree) => {
-                if worktrees.next().is_none() {
-                    Ok(Some(worktree.read(cx).abs_path().to_path_buf()))
-                } else {
-                    Err(anyhow!(
+                if worktrees.next().is_some() {
+                    bail!(
                         "'.' is ambiguous in multi-root workspaces. Please specify a root directory explicitly.",
-                    ))
+                    );
                 }
+                Ok(Some(worktree.read(cx).abs_path().to_path_buf()))
             }
             None => Ok(None),
         }
-    } else {
-        let input_path = Path::new(cd);
-
-        if input_path.is_absolute() {
-            // Absolute paths are allowed, but only if they're in one of the project's worktrees.
-            if project
-                .worktrees(cx)
-                .any(|worktree| input_path.starts_with(&worktree.read(cx).abs_path()))
-            {
-                return Ok(Some(input_path.into()));
-            }
-        } else {
-            if let Some(worktree) = project.worktree_for_root_name(cd, cx) {
-                return Ok(Some(worktree.read(cx).abs_path().to_path_buf()));
-            }
+    } else if input_path.is_absolute() {
+        // Absolute paths are allowed, but only if they're in one of the project's worktrees.
+        if !project
+            .worktrees(cx)
+            .any(|worktree| input_path.starts_with(&worktree.read(cx).abs_path()))
+        {
+            bail!("The absolute path must be within one of the project's worktrees");
         }
 
-        Err(anyhow!(
-            "`cd` directory {cd:?} was not in any of the project's worktrees."
-        ))
+        Ok(Some(input_path.into()))
+    } else {
+        let Some(worktree) = project.worktree_for_root_name(&input.cd, cx) else {
+            bail!("`cd` directory {:?} not found in the project", input.cd);
+        };
+
+        Ok(Some(worktree.read(cx).abs_path().to_path_buf()))
     }
 }
 
@@ -732,8 +723,8 @@ mod tests {
             )
         });
 
-        let output = result.output.await.log_err().unwrap().content;
-        assert_eq!(output.as_str().unwrap(), "Command executed successfully.");
+        let output = result.output.await.log_err().map(|output| output.content);
+        assert_eq!(output, Some("Command executed successfully.".into()));
     }
 
     #[gpui::test]
@@ -766,13 +757,12 @@ mod tests {
                 cx,
             );
             cx.spawn(async move |_| {
-                let output = headless_result.output.await.map(|output| output.content);
-                assert_eq!(
-                    output
-                        .ok()
-                        .and_then(|content| content.as_str().map(ToString::to_string)),
-                    expected
-                );
+                let output = headless_result
+                    .output
+                    .await
+                    .log_err()
+                    .map(|output| output.content);
+                assert_eq!(output, expected);
             })
         };
 
@@ -780,7 +770,7 @@ mod tests {
             check(
                 TerminalToolInput {
                     command: "pwd".into(),
-                    cd: ".".into(),
+                    cd: "project".into(),
                 },
                 Some(format!(
                     "```\n{}\n```",
@@ -795,9 +785,12 @@ mod tests {
             check(
                 TerminalToolInput {
                     command: "pwd".into(),
-                    cd: "other-project".into(),
+                    cd: ".".into(),
                 },
-                None, // other-project is a dir, but *not* a worktree (yet)
+                Some(format!(
+                    "```\n{}\n```",
+                    tree.path().join("project").display()
+                )),
                 cx,
             )
         })

crates/assistant_tools/src/web_search_tool.rs

@@ -3,9 +3,7 @@ use std::{sync::Arc, time::Duration};
 use crate::schema::json_schema_for;
 use crate::ui::ToolCallCardHeader;
 use anyhow::{Context as _, Result, anyhow};
-use assistant_tool::{
-    ActionLog, Tool, ToolCard, ToolResult, ToolResultContent, ToolResultOutput, ToolUseStatus,
-};
+use assistant_tool::{ActionLog, Tool, ToolCard, ToolResult, ToolUseStatus};
 use futures::{Future, FutureExt, TryFutureExt};
 use gpui::{
     AnyWindowHandle, App, AppContext, Context, Entity, IntoElement, Task, WeakEntity, Window,
@@ -75,13 +73,9 @@ impl Tool for WebSearchTool {
             let search_task = search_task.clone();
             async move {
                 let response = search_task.await.map_err(|err| anyhow!(err))?;
-                Ok(ToolResultOutput {
-                    content: ToolResultContent::Text(
-                        serde_json::to_string(&response)
-                            .context("Failed to serialize search results")?,
-                    ),
-                    output: Some(serde_json::to_value(response)?),
-                })
+                serde_json::to_string(&response)
+                    .context("Failed to serialize search results")
+                    .map(Into::into)
             }
         });
 
@@ -90,18 +84,6 @@ impl Tool for WebSearchTool {
             card: Some(cx.new(|cx| WebSearchToolCard::new(search_task, cx)).into()),
         }
     }
-
-    fn deserialize_card(
-        self: Arc<Self>,
-        output: serde_json::Value,
-        _project: Entity<Project>,
-        _window: &mut Window,
-        cx: &mut App,
-    ) -> Option<assistant_tool::AnyToolCard> {
-        let output = serde_json::from_value::<WebSearchResponse>(output).ok()?;
-        let card = cx.new(|cx| WebSearchToolCard::new(Task::ready(Ok(output)), cx));
-        Some(card.into())
-    }
 }
 
 #[derive(RegisterComponent)]

crates/bedrock/src/models.rs

@@ -38,7 +38,6 @@ pub enum Model {
     AmazonNovaLite,
     AmazonNovaMicro,
     AmazonNovaPro,
-    AmazonNovaPremier,
     // AI21 models
     AI21J2GrandeInstruct,
     AI21J2JumboInstruct,
@@ -73,10 +72,6 @@ pub enum Model {
     MistralMixtral8x7BInstructV0,
     MistralMistralLarge2402V1,
     MistralMistralSmall2402V1,
-    MistralPixtralLarge2502V1,
-    // Writer models
-    PalmyraWriterX5,
-    PalmyraWriterX4,
     #[serde(rename = "custom")]
     Custom {
         name: String,
@@ -125,7 +120,6 @@ impl Model {
             Model::AmazonNovaLite => "amazon.nova-lite-v1:0",
             Model::AmazonNovaMicro => "amazon.nova-micro-v1:0",
             Model::AmazonNovaPro => "amazon.nova-pro-v1:0",
-            Model::AmazonNovaPremier => "amazon.nova-premier-v1:0",
             Model::DeepSeekR1 => "us.deepseek.r1-v1:0",
             Model::AI21J2GrandeInstruct => "ai21.j2-grande-instruct",
             Model::AI21J2JumboInstruct => "ai21.j2-jumbo-instruct",
@@ -155,9 +149,6 @@ impl Model {
             Model::MistralMixtral8x7BInstructV0 => "mistral.mixtral-8x7b-instruct-v0:1",
             Model::MistralMistralLarge2402V1 => "mistral.mistral-large-2402-v1:0",
             Model::MistralMistralSmall2402V1 => "mistral.mistral-small-2402-v1:0",
-            Model::MistralPixtralLarge2502V1 => "mistral.pixtral-large-2502-v1:0",
-            Model::PalmyraWriterX4 => "writer.palmyra-x4-v1:0",
-            Model::PalmyraWriterX5 => "writer.palmyra-x5-v1:0",
             Self::Custom { name, .. } => name,
         }
     }
@@ -175,7 +166,6 @@ impl Model {
             Self::AmazonNovaLite => "Amazon Nova Lite",
             Self::AmazonNovaMicro => "Amazon Nova Micro",
             Self::AmazonNovaPro => "Amazon Nova Pro",
-            Self::AmazonNovaPremier => "Amazon Nova Premier",
             Self::DeepSeekR1 => "DeepSeek R1",
             Self::AI21J2GrandeInstruct => "AI21 Jurassic2 Grande Instruct",
             Self::AI21J2JumboInstruct => "AI21 Jurassic2 Jumbo Instruct",
@@ -205,9 +195,6 @@ impl Model {
             Self::MistralMixtral8x7BInstructV0 => "Mistral Mixtral 8x7B Instruct V0",
             Self::MistralMistralLarge2402V1 => "Mistral Large 2402 V1",
             Self::MistralMistralSmall2402V1 => "Mistral Small 2402 V1",
-            Self::MistralPixtralLarge2502V1 => "Pixtral Large 25.02 V1",
-            Self::PalmyraWriterX5 => "Writer Palmyra X5",
-            Self::PalmyraWriterX4 => "Writer Palmyra X4",
             Self::Custom {
                 display_name, name, ..
             } => display_name.as_deref().unwrap_or(name),
@@ -221,11 +208,8 @@ impl Model {
             | Self::Claude3Sonnet
             | Self::Claude3_5Haiku
             | Self::Claude3_7Sonnet => 200_000,
-            Self::AmazonNovaPremier => 1_000_000,
-            Self::PalmyraWriterX5 => 1_000_000,
-            Self::PalmyraWriterX4 => 128_000,
             Self::Custom { max_tokens, .. } => *max_tokens,
-            _ => 128_000,
+            _ => 200_000,
         }
     }
 
@@ -233,7 +217,7 @@ impl Model {
         match self {
             Self::Claude3Opus | Self::Claude3Sonnet | Self::Claude3_5Haiku => 4_096,
             Self::Claude3_7Sonnet | Self::Claude3_7SonnetThinking => 128_000,
-            Self::Claude3_5SonnetV2 | Self::PalmyraWriterX4 | Self::PalmyraWriterX5 => 8_192,
+            Self::Claude3_5SonnetV2 => 8_192,
             Self::Custom {
                 max_output_tokens, ..
             } => max_output_tokens.unwrap_or(4_096),
@@ -268,10 +252,7 @@ impl Model {
             | Self::Claude3_5Haiku => true,
 
             // Amazon Nova models (all support tool use)
-            Self::AmazonNovaPremier
-            | Self::AmazonNovaPro
-            | Self::AmazonNovaLite
-            | Self::AmazonNovaMicro => true,
+            Self::AmazonNovaPro | Self::AmazonNovaLite | Self::AmazonNovaMicro => true,
 
             // AI21 Jamba 1.5 models support tool use
             Self::AI21Jamba15LargeV1 | Self::AI21Jamba15MiniV1 => true,
@@ -324,11 +305,8 @@ impl Model {
 
             // Models available only in US
             (Model::Claude3Opus, "us")
-            | (Model::Claude3_5Haiku, "us")
             | (Model::Claude3_7Sonnet, "us")
-            | (Model::Claude3_7SonnetThinking, "us")
-            | (Model::AmazonNovaPremier, "us")
-            | (Model::MistralPixtralLarge2502V1, "us") => {
+            | (Model::Claude3_7SonnetThinking, "us") => {
                 Ok(format!("{}.{}", region_group, model_id))
             }
 
@@ -362,12 +340,6 @@ impl Model {
                 Ok(format!("{}.{}", region_group, model_id))
             }
 
-            // Writer models only available in the US
-            (Model::PalmyraWriterX4, "us") | (Model::PalmyraWriterX5, "us") => {
-                // They have some goofiness
-                Ok(format!("{}.{}", region_group, model_id))
-            }
-
             // Any other combination is not supported
             _ => Ok(self.id().into()),
         }

crates/call/src/call_settings.rs

@@ -12,7 +12,6 @@ pub struct CallSettings {
 
 /// Configuration of voice calls in Zed.
 #[derive(Clone, Default, Serialize, Deserialize, JsonSchema, Debug)]
-#[schemars(deny_unknown_fields)]
 pub struct CallSettingsContent {
     /// Whether the microphone should be muted when joining a channel or a call.
     ///

crates/collab_ui/src/collab_panel.rs

@@ -378,27 +378,16 @@ impl CollabPanel {
         workspace: WeakEntity<Workspace>,
         mut cx: AsyncWindowContext,
     ) -> anyhow::Result<Entity<Self>> {
-        let serialized_panel = match workspace
-            .read_with(&cx, |workspace, _| {
-                CollabPanel::serialization_key(workspace)
-            })
-            .ok()
+        let serialized_panel = cx
+            .background_spawn(async move { KEY_VALUE_STORE.read_kvp(COLLABORATION_PANEL_KEY) })
+            .await
+            .map_err(|_| anyhow::anyhow!("Failed to read collaboration panel from key value store"))
+            .log_err()
             .flatten()
-        {
-            Some(serialization_key) => cx
-                .background_spawn(async move { KEY_VALUE_STORE.read_kvp(&serialization_key) })
-                .await
-                .map_err(|_| {
-                    anyhow::anyhow!("Failed to read collaboration panel from key value store")
-                })
-                .log_err()
-                .flatten()
-                .map(|panel| serde_json::from_str::<SerializedCollabPanel>(&panel))
-                .transpose()
-                .log_err()
-                .flatten(),
-            None => None,
-        };
+            .map(|panel| serde_json::from_str::<SerializedCollabPanel>(&panel))
+            .transpose()
+            .log_err()
+            .flatten();
 
         workspace.update_in(&mut cx, |workspace, window, cx| {
             let panel = CollabPanel::new(workspace, window, cx);
@@ -418,30 +407,14 @@ impl CollabPanel {
         })
     }
 
-    fn serialization_key(workspace: &Workspace) -> Option<String> {
-        workspace
-            .database_id()
-            .map(|id| i64::from(id).to_string())
-            .or(workspace.session_id())
-            .map(|id| format!("{}-{:?}", COLLABORATION_PANEL_KEY, id))
-    }
-
     fn serialize(&mut self, cx: &mut Context<Self>) {
-        let Some(serialization_key) = self
-            .workspace
-            .update(cx, |workspace, _| CollabPanel::serialization_key(workspace))
-            .ok()
-            .flatten()
-        else {
-            return;
-        };
         let width = self.width;
         let collapsed_channels = self.collapsed_channels.clone();
         self.pending_serialization = cx.background_spawn(
             async move {
                 KEY_VALUE_STORE
                     .write_kvp(
-                        serialization_key,
+                        COLLABORATION_PANEL_KEY.into(),
                         serde_json::to_string(&SerializedCollabPanel {
                             width,
                             collapsed_channels: Some(
@@ -3026,12 +2999,10 @@ impl Panel for CollabPanel {
             .unwrap_or_else(|| CollaborationPanelSettings::get_global(cx).default_width)
     }
 
-    fn set_size(&mut self, size: Option<Pixels>, window: &mut Window, cx: &mut Context<Self>) {
+    fn set_size(&mut self, size: Option<Pixels>, _: &mut Window, cx: &mut Context<Self>) {
         self.width = size;
+        self.serialize(cx);
         cx.notify();
-        cx.defer_in(window, |this, _, cx| {
-            this.serialize(cx);
-        });
     }
 
     fn icon(&self, _window: &Window, cx: &App) -> Option<ui::IconName> {

crates/collab_ui/src/panel_settings.rs

@@ -28,7 +28,6 @@ pub struct ChatPanelSettings {
 }
 
 #[derive(Clone, Default, Serialize, Deserialize, JsonSchema, Debug)]
-#[schemars(deny_unknown_fields)]
 pub struct ChatPanelSettingsContent {
     /// When to show the panel button in the status bar.
     ///
@@ -52,7 +51,6 @@ pub struct NotificationPanelSettings {
 }
 
 #[derive(Clone, Default, Serialize, Deserialize, JsonSchema, Debug)]
-#[schemars(deny_unknown_fields)]
 pub struct PanelSettingsContent {
     /// Whether to show the panel button in the status bar.
     ///
@@ -69,7 +67,6 @@ pub struct PanelSettingsContent {
 }
 
 #[derive(Clone, Default, Serialize, Deserialize, JsonSchema, Debug)]
-#[schemars(deny_unknown_fields)]
 pub struct MessageEditorSettings {
     /// Whether to automatically replace emoji shortcodes with emoji characters.
     /// For example: typing `:wave:` gets replaced with `👋`.

crates/copilot/Cargo.toml

@@ -14,6 +14,7 @@ doctest = false
 
 [features]
 default = []
+schemars = ["dep:schemars"]
 test-support = [
     "collections/test-support",
     "gpui/test-support",
@@ -42,15 +43,16 @@ node_runtime.workspace = true
 parking_lot.workspace = true
 paths.workspace = true
 project.workspace = true
+schemars = { workspace = true, optional = true }
 serde.workspace = true
 serde_json.workspace = true
 settings.workspace = true
+strum.workspace = true
 task.workspace = true
 ui.workspace = true
 util.workspace = true
 workspace.workspace = true
 workspace-hack.workspace = true
-itertools.workspace = true
 
 [target.'cfg(windows)'.dependencies]
 async-std = { version = "1.12.0", features = ["unstable"] }

crates/copilot/src/copilot_chat.rs

@@ -9,20 +9,13 @@ use fs::Fs;
 use futures::{AsyncBufReadExt, AsyncReadExt, StreamExt, io::BufReader, stream::BoxStream};
 use gpui::{App, AsyncApp, Global, prelude::*};
 use http_client::{AsyncBody, HttpClient, Method, Request as HttpRequest};
-use itertools::Itertools;
 use paths::home_dir;
 use serde::{Deserialize, Serialize};
 use settings::watch_config_dir;
+use strum::EnumIter;
 
 pub const COPILOT_CHAT_COMPLETION_URL: &str = "https://api.githubcopilot.com/chat/completions";
 pub const COPILOT_CHAT_AUTH_URL: &str = "https://api.github.com/copilot_internal/v2/token";
-pub const COPILOT_CHAT_MODELS_URL: &str = "https://api.githubcopilot.com/models";
-
-// Copilot's base model; defined by Microsoft in premium requests table
-// This will be moved to the front of the Copilot model list, and will be used for
-// 'fast' requests (e.g. title generation)
-// https://docs.github.com/en/copilot/managing-copilot/monitoring-usage-and-entitlements/about-premium-requests
-const DEFAULT_MODEL_ID: &str = "gpt-4.1";
 
 #[derive(Clone, Copy, Serialize, Deserialize, Debug, Eq, PartialEq)]
 #[serde(rename_all = "lowercase")]
@@ -32,130 +25,132 @@ pub enum Role {
     System,
 }
 
-#[derive(Deserialize)]
-struct ModelSchema {
-    #[serde(deserialize_with = "deserialize_models_skip_errors")]
-    data: Vec<Model>,
-}
-
-fn deserialize_models_skip_errors<'de, D>(deserializer: D) -> Result<Vec<Model>, D::Error>
-where
-    D: serde::Deserializer<'de>,
-{
-    let raw_values = Vec::<serde_json::Value>::deserialize(deserializer)?;
-    let models = raw_values
-        .into_iter()
-        .filter_map(|value| match serde_json::from_value::<Model>(value) {
-            Ok(model) => Some(model),
-            Err(err) => {
-                log::warn!("GitHub Copilot Chat model failed to deserialize: {:?}", err);
-                None
-            }
-        })
-        .collect();
-
-    Ok(models)
-}
-
-#[derive(Clone, Serialize, Deserialize, Debug, Eq, PartialEq)]
-pub struct Model {
-    capabilities: ModelCapabilities,
-    id: String,
-    name: String,
-    policy: Option<ModelPolicy>,
-    vendor: ModelVendor,
-    model_picker_enabled: bool,
-}
-
-#[derive(Clone, Serialize, Deserialize, Debug, Eq, PartialEq)]
-struct ModelCapabilities {
-    family: String,
-    #[serde(default)]
-    limits: ModelLimits,
-    supports: ModelSupportedFeatures,
-}
-
-#[derive(Default, Clone, Serialize, Deserialize, Debug, Eq, PartialEq)]
-struct ModelLimits {
-    #[serde(default)]
-    max_context_window_tokens: usize,
-    #[serde(default)]
-    max_output_tokens: usize,
-    #[serde(default)]
-    max_prompt_tokens: usize,
-}
-
-#[derive(Clone, Serialize, Deserialize, Debug, Eq, PartialEq)]
-struct ModelPolicy {
-    state: String,
-}
-
-#[derive(Clone, Serialize, Deserialize, Debug, Eq, PartialEq)]
-struct ModelSupportedFeatures {
-    #[serde(default)]
-    streaming: bool,
-    #[serde(default)]
-    tool_calls: bool,
-    #[serde(default)]
-    parallel_tool_calls: bool,
-    #[serde(default)]
-    vision: bool,
-}
-
-#[derive(Clone, Copy, Serialize, Deserialize, Debug, Eq, PartialEq)]
-pub enum ModelVendor {
-    // Azure OpenAI should have no functional difference from OpenAI in Copilot Chat
-    #[serde(alias = "Azure OpenAI")]
-    OpenAI,
-    Google,
-    Anthropic,
-}
-
-#[derive(Serialize, Deserialize, Debug, Eq, PartialEq, Clone)]
-#[serde(tag = "type")]
-pub enum ChatMessagePart {
-    #[serde(rename = "text")]
-    Text { text: String },
-    #[serde(rename = "image_url")]
-    Image { image_url: ImageUrl },
-}
-
-#[derive(Serialize, Deserialize, Debug, Eq, PartialEq, Clone)]
-pub struct ImageUrl {
-    pub url: String,
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Clone, Debug, Default, Serialize, Deserialize, PartialEq, EnumIter)]
+pub enum Model {
+    #[default]
+    #[serde(alias = "gpt-4o", rename = "gpt-4o-2024-05-13")]
+    Gpt4o,
+    #[serde(alias = "gpt-4", rename = "gpt-4")]
+    Gpt4,
+    #[serde(alias = "gpt-4.1", rename = "gpt-4.1")]
+    Gpt4_1,
+    #[serde(alias = "gpt-3.5-turbo", rename = "gpt-3.5-turbo")]
+    Gpt3_5Turbo,
+    #[serde(alias = "o1", rename = "o1")]
+    O1,
+    #[serde(alias = "o1-mini", rename = "o3-mini")]
+    O3Mini,
+    #[serde(alias = "o3", rename = "o3")]
+    O3,
+    #[serde(alias = "o4-mini", rename = "o4-mini")]
+    O4Mini,
+    #[serde(alias = "claude-3-5-sonnet", rename = "claude-3.5-sonnet")]
+    Claude3_5Sonnet,
+    #[serde(alias = "claude-3-7-sonnet", rename = "claude-3.7-sonnet")]
+    Claude3_7Sonnet,
+    #[serde(
+        alias = "claude-3.7-sonnet-thought",
+        rename = "claude-3.7-sonnet-thought"
+    )]
+    Claude3_7SonnetThinking,
+    #[serde(alias = "gemini-2.0-flash", rename = "gemini-2.0-flash-001")]
+    Gemini20Flash,
+    #[serde(alias = "gemini-2.5-pro", rename = "gemini-2.5-pro")]
+    Gemini25Pro,
 }
 
 impl Model {
+    pub fn default_fast() -> Self {
+        Self::Claude3_7Sonnet
+    }
+
     pub fn uses_streaming(&self) -> bool {
-        self.capabilities.supports.streaming
+        match self {
+            Self::Gpt4o
+            | Self::Gpt4
+            | Self::Gpt4_1
+            | Self::Gpt3_5Turbo
+            | Self::O3
+            | Self::O4Mini
+            | Self::Claude3_5Sonnet
+            | Self::Claude3_7Sonnet
+            | Self::Claude3_7SonnetThinking => true,
+            Self::O3Mini | Self::O1 | Self::Gemini20Flash | Self::Gemini25Pro => false,
+        }
     }
 
-    pub fn id(&self) -> &str {
-        self.id.as_str()
+    pub fn from_id(id: &str) -> Result<Self> {
+        match id {
+            "gpt-4o" => Ok(Self::Gpt4o),
+            "gpt-4" => Ok(Self::Gpt4),
+            "gpt-4.1" => Ok(Self::Gpt4_1),
+            "gpt-3.5-turbo" => Ok(Self::Gpt3_5Turbo),
+            "o1" => Ok(Self::O1),
+            "o3-mini" => Ok(Self::O3Mini),
+            "o3" => Ok(Self::O3),
+            "o4-mini" => Ok(Self::O4Mini),
+            "claude-3-5-sonnet" => Ok(Self::Claude3_5Sonnet),
+            "claude-3-7-sonnet" => Ok(Self::Claude3_7Sonnet),
+            "claude-3.7-sonnet-thought" => Ok(Self::Claude3_7SonnetThinking),
+            "gemini-2.0-flash-001" => Ok(Self::Gemini20Flash),
+            "gemini-2.5-pro" => Ok(Self::Gemini25Pro),
+            _ => Err(anyhow!("Invalid model id: {}", id)),
+        }
     }
 
-    pub fn display_name(&self) -> &str {
-        self.name.as_str()
+    pub fn id(&self) -> &'static str {
+        match self {
+            Self::Gpt3_5Turbo => "gpt-3.5-turbo",
+            Self::Gpt4 => "gpt-4",
+            Self::Gpt4_1 => "gpt-4.1",
+            Self::Gpt4o => "gpt-4o",
+            Self::O3Mini => "o3-mini",
+            Self::O1 => "o1",
+            Self::O3 => "o3",
+            Self::O4Mini => "o4-mini",
+            Self::Claude3_5Sonnet => "claude-3-5-sonnet",
+            Self::Claude3_7Sonnet => "claude-3-7-sonnet",
+            Self::Claude3_7SonnetThinking => "claude-3.7-sonnet-thought",
+            Self::Gemini20Flash => "gemini-2.0-flash-001",
+            Self::Gemini25Pro => "gemini-2.5-pro",
+        }
+    }
+
+    pub fn display_name(&self) -> &'static str {
+        match self {
+            Self::Gpt3_5Turbo => "GPT-3.5",
+            Self::Gpt4 => "GPT-4",
+            Self::Gpt4_1 => "GPT-4.1",
+            Self::Gpt4o => "GPT-4o",
+            Self::O3Mini => "o3-mini",
+            Self::O1 => "o1",
+            Self::O3 => "o3",
+            Self::O4Mini => "o4-mini",
+            Self::Claude3_5Sonnet => "Claude 3.5 Sonnet",
+            Self::Claude3_7Sonnet => "Claude 3.7 Sonnet",
+            Self::Claude3_7SonnetThinking => "Claude 3.7 Sonnet Thinking",
+            Self::Gemini20Flash => "Gemini 2.0 Flash",
+            Self::Gemini25Pro => "Gemini 2.5 Pro",
+        }
     }
 
     pub fn max_token_count(&self) -> usize {
-        self.capabilities.limits.max_prompt_tokens
-    }
-
-    pub fn supports_tools(&self) -> bool {
-        self.capabilities.supports.tool_calls
-    }
-
-    pub fn vendor(&self) -> ModelVendor {
-        self.vendor
-    }
-
-    pub fn supports_vision(&self) -> bool {
-        self.capabilities.supports.vision
-    }
-
-    pub fn supports_parallel_tool_calls(&self) -> bool {
-        self.capabilities.supports.parallel_tool_calls
+        match self {
+            Self::Gpt4o => 64_000,
+            Self::Gpt4 => 32_768,
+            Self::Gpt4_1 => 128_000,
+            Self::Gpt3_5Turbo => 12_288,
+            Self::O3Mini => 64_000,
+            Self::O1 => 20_000,
+            Self::O3 => 128_000,
+            Self::O4Mini => 128_000,
+            Self::Claude3_5Sonnet => 200_000,
+            Self::Claude3_7Sonnet => 90_000,
+            Self::Claude3_7SonnetThinking => 90_000,
+            Self::Gemini20Flash => 128_000,
+            Self::Gemini25Pro => 128_000,
+        }
     }
 }
 
@@ -165,7 +160,7 @@ pub struct Request {
     pub n: usize,
     pub stream: bool,
     pub temperature: f32,
-    pub model: String,
+    pub model: Model,
     pub messages: Vec<ChatMessage>,
     #[serde(default, skip_serializing_if = "Vec::is_empty")]
     pub tools: Vec<Tool>,
@@ -194,55 +189,26 @@ pub enum ToolChoice {
     None,
 }
 
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Serialize, Deserialize, Debug, Eq, PartialEq)]
 #[serde(tag = "role", rename_all = "lowercase")]
 pub enum ChatMessage {
     Assistant {
-        content: ChatMessageContent,
+        content: Option<String>,
         #[serde(default, skip_serializing_if = "Vec::is_empty")]
         tool_calls: Vec<ToolCall>,
     },
     User {
-        content: ChatMessageContent,
+        content: String,
     },
     System {
         content: String,
     },
     Tool {
-        content: ChatMessageContent,
+        content: String,
         tool_call_id: String,
     },
 }
 
-#[derive(Debug, Serialize, Deserialize)]
-#[serde(untagged)]
-pub enum ChatMessageContent {
-    Plain(String),
-    Multipart(Vec<ChatMessagePart>),
-}
-
-impl ChatMessageContent {
-    pub fn empty() -> Self {
-        ChatMessageContent::Multipart(vec![])
-    }
-}
-
-impl From<Vec<ChatMessagePart>> for ChatMessageContent {
-    fn from(mut parts: Vec<ChatMessagePart>) -> Self {
-        if let [ChatMessagePart::Text { text }] = parts.as_mut_slice() {
-            ChatMessageContent::Plain(std::mem::take(text))
-        } else {
-            ChatMessageContent::Multipart(parts)
-        }
-    }
-}
-
-impl From<String> for ChatMessageContent {
-    fn from(text: String) -> Self {
-        ChatMessageContent::Plain(text)
-    }
-}
-
 #[derive(Serialize, Deserialize, Debug, Eq, PartialEq)]
 pub struct ToolCall {
     pub id: String,
@@ -266,6 +232,7 @@ pub struct FunctionContent {
 #[serde(tag = "type", rename_all = "snake_case")]
 pub struct ResponseEvent {
     pub choices: Vec<ResponseChoice>,
+    pub created: u64,
     pub id: String,
 }
 
@@ -339,7 +306,6 @@ impl Global for GlobalCopilotChat {}
 pub struct CopilotChat {
     oauth_token: Option<String>,
     api_token: Option<ApiToken>,
-    models: Option<Vec<Model>>,
     client: Arc<dyn HttpClient>,
 }
 
@@ -376,56 +342,31 @@ impl CopilotChat {
         let config_paths: HashSet<PathBuf> = copilot_chat_config_paths().into_iter().collect();
         let dir_path = copilot_chat_config_dir();
 
-        cx.spawn({
-            let client = client.clone();
-            async move |cx| {
-                let mut parent_watch_rx = watch_config_dir(
-                    cx.background_executor(),
-                    fs.clone(),
-                    dir_path.clone(),
-                    config_paths,
-                );
-                while let Some(contents) = parent_watch_rx.next().await {
-                    let oauth_token = extract_oauth_token(contents);
-                    cx.update(|cx| {
-                        if let Some(this) = Self::global(cx).as_ref() {
-                            this.update(cx, |this, cx| {
-                                this.oauth_token = oauth_token.clone();
-                                cx.notify();
-                            });
-                        }
-                    })?;
-
-                    if let Some(ref oauth_token) = oauth_token {
-                        let api_token = request_api_token(oauth_token, client.clone()).await?;
-                        cx.update(|cx| {
-                            if let Some(this) = Self::global(cx).as_ref() {
-                                this.update(cx, |this, cx| {
-                                    this.api_token = Some(api_token.clone());
-                                    cx.notify();
-                                });
-                            }
-                        })?;
-                        let models = get_models(api_token.api_key, client.clone()).await?;
-                        cx.update(|cx| {
-                            if let Some(this) = Self::global(cx).as_ref() {
-                                this.update(cx, |this, cx| {
-                                    this.models = Some(models);
-                                    cx.notify();
-                                });
-                            }
-                        })?;
+        cx.spawn(async move |cx| {
+            let mut parent_watch_rx = watch_config_dir(
+                cx.background_executor(),
+                fs.clone(),
+                dir_path.clone(),
+                config_paths,
+            );
+            while let Some(contents) = parent_watch_rx.next().await {
+                let oauth_token = extract_oauth_token(contents);
+                cx.update(|cx| {
+                    if let Some(this) = Self::global(cx).as_ref() {
+                        this.update(cx, |this, cx| {
+                            this.oauth_token = oauth_token;
+                            cx.notify();
+                        });
                     }
-                }
-                anyhow::Ok(())
+                })?;
             }
+            anyhow::Ok(())
         })
         .detach_and_log_err(cx);
 
         Self {
             oauth_token: None,
             api_token: None,
-            models: None,
             client,
         }
     }
@@ -434,10 +375,6 @@ impl CopilotChat {
         self.oauth_token.is_some()
     }
 
-    pub fn models(&self) -> Option<&[Model]> {
-        self.models.as_deref()
-    }
-
     pub async fn stream_completion(
         request: Request,
         mut cx: AsyncApp,
@@ -472,61 +409,6 @@ impl CopilotChat {
     }
 }
 
-async fn get_models(api_token: String, client: Arc<dyn HttpClient>) -> Result<Vec<Model>> {
-    let all_models = request_models(api_token, client).await?;
-
-    let mut models: Vec<Model> = all_models
-        .into_iter()
-        .filter(|model| {
-            // Ensure user has access to the model; Policy is present only for models that must be
-            // enabled in the GitHub dashboard
-            model.model_picker_enabled
-                && model
-                    .policy
-                    .as_ref()
-                    .is_none_or(|policy| policy.state == "enabled")
-        })
-        // The first model from the API response, in any given family, appear to be the non-tagged
-        // models, which are likely the best choice (e.g. gpt-4o rather than gpt-4o-2024-11-20)
-        .dedup_by(|a, b| a.capabilities.family == b.capabilities.family)
-        .collect();
-
-    if let Some(default_model_position) =
-        models.iter().position(|model| model.id == DEFAULT_MODEL_ID)
-    {
-        let default_model = models.remove(default_model_position);
-        models.insert(0, default_model);
-    }
-
-    Ok(models)
-}
-
-async fn request_models(api_token: String, client: Arc<dyn HttpClient>) -> Result<Vec<Model>> {
-    let request_builder = HttpRequest::builder()
-        .method(Method::GET)
-        .uri(COPILOT_CHAT_MODELS_URL)
-        .header("Authorization", format!("Bearer {}", api_token))
-        .header("Content-Type", "application/json")
-        .header("Copilot-Integration-Id", "vscode-chat");
-
-    let request = request_builder.body(AsyncBody::empty())?;
-
-    let mut response = client.send(request).await?;
-
-    if response.status().is_success() {
-        let mut body = Vec::new();
-        response.body_mut().read_to_end(&mut body).await?;
-
-        let body_str = std::str::from_utf8(&body)?;
-
-        let models = serde_json::from_str::<ModelSchema>(body_str)?.data;
-
-        Ok(models)
-    } else {
-        Err(anyhow!("Failed to request models: {}", response.status()))
-    }
-}
-
 async fn request_api_token(oauth_token: &str, client: Arc<dyn HttpClient>) -> Result<ApiToken> {
     let request_builder = HttpRequest::builder()
         .method(Method::GET)
@@ -590,8 +472,7 @@ async fn stream_completion(
         )
         .header("Authorization", format!("Bearer {}", api_key))
         .header("Content-Type", "application/json")
-        .header("Copilot-Integration-Id", "vscode-chat")
-        .header("Copilot-Vision-Request", "true");
+        .header("Copilot-Integration-Id", "vscode-chat");
 
     let is_streaming = request.stream;
 
@@ -646,82 +527,3 @@ async fn stream_completion(
         Ok(futures::stream::once(async move { Ok(response) }).boxed())
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_resilient_model_schema_deserialize() {
-        let json = r#"{
-              "data": [
-                {
-                  "capabilities": {
-                    "family": "gpt-4",
-                    "limits": {
-                      "max_context_window_tokens": 32768,
-                      "max_output_tokens": 4096,
-                      "max_prompt_tokens": 32768
-                    },
-                    "object": "model_capabilities",
-                    "supports": { "streaming": true, "tool_calls": true },
-                    "tokenizer": "cl100k_base",
-                    "type": "chat"
-                  },
-                  "id": "gpt-4",
-                  "model_picker_enabled": false,
-                  "name": "GPT 4",
-                  "object": "model",
-                  "preview": false,
-                  "vendor": "Azure OpenAI",
-                  "version": "gpt-4-0613"
-                },
-                {
-                    "some-unknown-field": 123
-                },
-                {
-                  "capabilities": {
-                    "family": "claude-3.7-sonnet",
-                    "limits": {
-                      "max_context_window_tokens": 200000,
-                      "max_output_tokens": 16384,
-                      "max_prompt_tokens": 90000,
-                      "vision": {
-                        "max_prompt_image_size": 3145728,
-                        "max_prompt_images": 1,
-                        "supported_media_types": ["image/jpeg", "image/png", "image/webp"]
-                      }
-                    },
-                    "object": "model_capabilities",
-                    "supports": {
-                      "parallel_tool_calls": true,
-                      "streaming": true,
-                      "tool_calls": true,
-                      "vision": true
-                    },
-                    "tokenizer": "o200k_base",
-                    "type": "chat"
-                  },
-                  "id": "claude-3.7-sonnet",
-                  "model_picker_enabled": true,
-                  "name": "Claude 3.7 Sonnet",
-                  "object": "model",
-                  "policy": {
-                    "state": "enabled",
-                    "terms": "Enable access to the latest Claude 3.7 Sonnet model from Anthropic. [Learn more about how GitHub Copilot serves Claude 3.7 Sonnet](https://docs.github.com/copilot/using-github-copilot/using-claude-sonnet-in-github-copilot)."
-                  },
-                  "preview": false,
-                  "vendor": "Anthropic",
-                  "version": "claude-3.7-sonnet"
-                }
-              ],
-              "object": "list"
-            }"#;
-
-        let schema: ModelSchema = serde_json::from_str(&json).unwrap();
-
-        assert_eq!(schema.data.len(), 2);
-        assert_eq!(schema.data[0].id, "gpt-4");
-        assert_eq!(schema.data[1].id, "claude-3.7-sonnet");
-    }
-}

crates/dap/src/adapters.rs

@@ -4,11 +4,11 @@ use async_compression::futures::bufread::GzipDecoder;
 use async_tar::Archive;
 use async_trait::async_trait;
 use collections::HashMap;
-pub use dap_types::{StartDebuggingRequestArguments, StartDebuggingRequestArgumentsRequest};
+use dap_types::{StartDebuggingRequestArguments, StartDebuggingRequestArgumentsRequest};
 use futures::io::BufReader;
 use gpui::{AsyncApp, SharedString};
 pub use http_client::{HttpClient, github::latest_github_release};
-use language::{LanguageName, LanguageToolchainStore};
+use language::LanguageToolchainStore;
 use node_runtime::NodeRuntime;
 use serde::{Deserialize, Serialize};
 use settings::WorktreeId;
@@ -418,11 +418,6 @@ pub trait DebugAdapter: 'static + Send + Sync {
         user_installed_path: Option<PathBuf>,
         cx: &mut AsyncApp,
     ) -> Result<DebugAdapterBinary>;
-
-    /// Returns the language name of an adapter if it only supports one language
-    fn adapter_language_name(&self) -> Option<LanguageName> {
-        None
-    }
 }
 
 #[cfg(any(test, feature = "test-support"))]

crates/dap/src/client.rs

@@ -7,14 +7,21 @@ use dap_types::{
     messages::{Message, Response},
     requests::Request,
 };
-use futures::channel::oneshot;
-use gpui::{AppContext, AsyncApp};
+use futures::{FutureExt as _, channel::oneshot, select};
+use gpui::{AppContext, AsyncApp, BackgroundExecutor};
 use smol::channel::{Receiver, Sender};
 use std::{
     hash::Hash,
     sync::atomic::{AtomicU64, Ordering},
+    time::Duration,
 };
 
+#[cfg(any(test, feature = "test-support"))]
+const DAP_REQUEST_TIMEOUT: Duration = Duration::from_secs(2);
+
+#[cfg(not(any(test, feature = "test-support")))]
+const DAP_REQUEST_TIMEOUT: Duration = Duration::from_secs(12);
+
 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
 #[repr(transparent)]
 pub struct SessionId(pub u32);
@@ -34,6 +41,7 @@ pub struct DebugAdapterClient {
     id: SessionId,
     sequence_count: AtomicU64,
     binary: DebugAdapterBinary,
+    executor: BackgroundExecutor,
     transport_delegate: TransportDelegate,
 }
 
@@ -53,6 +61,7 @@ impl DebugAdapterClient {
             binary,
             transport_delegate,
             sequence_count: AtomicU64::new(1),
+            executor: cx.background_executor().clone(),
         };
         log::info!("Successfully connected to debug adapter");
 
@@ -164,33 +173,40 @@ impl DebugAdapterClient {
 
         self.send_message(Message::Request(request)).await?;
 
+        let mut timeout = self.executor.timer(DAP_REQUEST_TIMEOUT).fuse();
         let command = R::COMMAND.to_string();
 
-        let response = callback_rx.await??;
-        log::debug!(
-            "Client {} received response for: `{}` sequence_id: {}",
-            self.id.0,
-            command,
-            sequence_id
-        );
-        match response.success {
-            true => {
-                if let Some(json) = response.body {
-                    Ok(serde_json::from_value(json)?)
-                // Note: dap types configure themselves to return `None` when an empty object is received,
-                // which then fails here...
-                } else if let Ok(result) =
-                    serde_json::from_value(serde_json::Value::Object(Default::default()))
-                {
-                    Ok(result)
-                } else {
-                    Ok(serde_json::from_value(Default::default())?)
+        select! {
+            response = callback_rx.fuse() => {
+                log::debug!(
+                    "Client {} received response for: `{}` sequence_id: {}",
+                    self.id.0,
+                    command,
+                    sequence_id
+                );
+
+                let response = response??;
+                match response.success {
+                    true => {
+                        if let Some(json) = response.body {
+                            Ok(serde_json::from_value(json)?)
+                        // Note: dap types configure themselves to return `None` when an empty object is received,
+                        // which then fails here...
+                        } else if let Ok(result) = serde_json::from_value(serde_json::Value::Object(Default::default())) {
+                            Ok(result)
+                        } else {
+                            Ok(serde_json::from_value(Default::default())?)
+                        }
+                    }
+                    false => Err(anyhow!("Request failed: {}", response.message.unwrap_or_default())),
                 }
             }
-            false => Err(anyhow!(
-                "Request failed: {}",
-                response.message.unwrap_or_default()
-            )),
+
+            _ = timeout => {
+                self.transport_delegate.cancel_pending_request(&sequence_id).await;
+                log::error!("Cancelled DAP request for {command:?} id {sequence_id} which took over {DAP_REQUEST_TIMEOUT:?}");
+                anyhow::bail!("DAP request timeout");
+            }
         }
     }
 

crates/dap/src/inline_value.rs

@@ -29,7 +29,7 @@ pub struct InlineValueLocation {
 /// during debugging sessions. Implementors must also handle variable scoping
 /// themselves by traversing the syntax tree upwards to determine whether a
 /// variable is local or global.
-pub trait InlineValueProvider: 'static + Send + Sync {
+pub trait InlineValueProvider {
     /// Provides a list of inline value locations based on the given node and source code.
     ///
     /// # Parameters

crates/dap/src/registry.rs

@@ -2,7 +2,6 @@ use anyhow::Result;
 use async_trait::async_trait;
 use collections::FxHashMap;
 use gpui::{App, Global, SharedString};
-use language::LanguageName;
 use parking_lot::RwLock;
 use task::{DebugRequest, DebugScenario, SpawnInTerminal, TaskTemplate};
 
@@ -60,11 +59,6 @@ impl DapRegistry {
         );
     }
 
-    pub fn adapter_language(&self, adapter_name: &str) -> Option<LanguageName> {
-        self.adapter(adapter_name)
-            .and_then(|adapter| adapter.adapter_language_name())
-    }
-
     pub fn add_locator(&self, locator: Arc<dyn DapLocator>) {
         let _previous_value = self.0.write().locators.insert(locator.name(), locator);
         debug_assert!(

crates/dap/src/transport.rs

@@ -224,6 +224,11 @@ impl TransportDelegate {
         pending_requests.insert(sequence_id, request);
     }
 
+    pub(crate) async fn cancel_pending_request(&self, sequence_id: &u64) {
+        let mut pending_requests = self.pending_requests.lock().await;
+        pending_requests.remove(sequence_id);
+    }
+
     pub(crate) async fn send_message(&self, message: Message) -> Result<()> {
         if let Some(server_tx) = self.server_tx.lock().await.as_ref() {
             server_tx

crates/dap_adapters/src/codelldb.rs

@@ -42,9 +42,7 @@ impl CodeLldbDebugAdapter {
                 if !launch.args.is_empty() {
                     map.insert("args".into(), launch.args.clone().into());
                 }
-                if !launch.env.is_empty() {
-                    map.insert("env".into(), launch.env_json());
-                }
+
                 if let Some(stop_on_entry) = config.stop_on_entry {
                     map.insert("stopOnEntry".into(), stop_on_entry.into());
                 }

crates/dap_adapters/src/gdb.rs

@@ -35,10 +35,6 @@ impl GdbDebugAdapter {
                     map.insert("args".into(), launch.args.clone().into());
                 }
 
-                if !launch.env.is_empty() {
-                    map.insert("env".into(), launch.env_json());
-                }
-
                 if let Some(stop_on_entry) = config.stop_on_entry {
                     map.insert(
                         "stopAtBeginningOfMainSubprogram".into(),

crates/dap_adapters/src/go.rs

@@ -1,6 +1,5 @@
 use dap::{StartDebuggingRequestArguments, adapters::DebugTaskDefinition};
-use gpui::{AsyncApp, SharedString};
-use language::LanguageName;
+use gpui::AsyncApp;
 use std::{collections::HashMap, ffi::OsStr, path::PathBuf};
 
 use crate::*;
@@ -20,8 +19,7 @@ impl GoDebugAdapter {
             dap::DebugRequest::Launch(launch_config) => json!({
                 "program": launch_config.program,
                 "cwd": launch_config.cwd,
-                "args": launch_config.args,
-                "env": launch_config.env_json()
+                "args": launch_config.args
             }),
         };
 
@@ -44,10 +42,6 @@ impl DebugAdapter for GoDebugAdapter {
         DebugAdapterName(Self::ADAPTER_NAME.into())
     }
 
-    fn adapter_language_name(&self) -> Option<LanguageName> {
-        Some(SharedString::new_static("Go").into())
-    }
-
     async fn get_binary(
         &self,
         delegate: &dyn DapDelegate,

crates/dap_adapters/src/javascript.rs

@@ -36,9 +36,6 @@ impl JsDebugAdapter {
                 if !launch.args.is_empty() {
                     map.insert("args".into(), launch.args.clone().into());
                 }
-                if !launch.env.is_empty() {
-                    map.insert("env".into(), launch.env_json());
-                }
 
                 if let Some(stop_on_entry) = config.stop_on_entry {
                     map.insert("stopOnEntry".into(), stop_on_entry.into());

crates/dap_adapters/src/php.rs

@@ -1,7 +1,6 @@
 use adapters::latest_github_release;
 use dap::adapters::{DebugTaskDefinition, TcpArguments};
-use gpui::{AsyncApp, SharedString};
-use language::LanguageName;
+use gpui::AsyncApp;
 use std::{collections::HashMap, path::PathBuf, sync::OnceLock};
 use util::ResultExt;
 
@@ -30,7 +29,6 @@ impl PhpDebugAdapter {
                     "program": launch_config.program,
                     "cwd": launch_config.cwd,
                     "args": launch_config.args,
-                    "env": launch_config.env_json(),
                     "stopOnEntry": config.stop_on_entry.unwrap_or_default(),
                 }),
                 request: config.request.to_dap(),
@@ -120,10 +118,6 @@ impl DebugAdapter for PhpDebugAdapter {
         DebugAdapterName(Self::ADAPTER_NAME.into())
     }
 
-    fn adapter_language_name(&self) -> Option<LanguageName> {
-        Some(SharedString::new_static("PHP").into())
-    }
-
     async fn get_binary(
         &self,
         delegate: &dyn DapDelegate,

crates/dap_adapters/src/python.rs

@@ -1,7 +1,6 @@
 use crate::*;
 use dap::{DebugRequest, StartDebuggingRequestArguments, adapters::DebugTaskDefinition};
-use gpui::{AsyncApp, SharedString};
-use language::LanguageName;
+use gpui::AsyncApp;
 use std::{collections::HashMap, ffi::OsStr, path::PathBuf, sync::OnceLock};
 use util::ResultExt;
 
@@ -33,9 +32,6 @@ impl PythonDebugAdapter {
             DebugRequest::Launch(launch) => {
                 map.insert("program".into(), launch.program.clone().into());
                 map.insert("args".into(), launch.args.clone().into());
-                if !launch.env.is_empty() {
-                    map.insert("env".into(), launch.env_json());
-                }
 
                 if let Some(stop_on_entry) = config.stop_on_entry {
                     map.insert("stopOnEntry".into(), stop_on_entry.into());
@@ -166,10 +162,6 @@ impl DebugAdapter for PythonDebugAdapter {
         DebugAdapterName(Self::ADAPTER_NAME.into())
     }
 
-    fn adapter_language_name(&self) -> Option<LanguageName> {
-        Some(SharedString::new_static("Python").into())
-    }
-
     async fn get_binary(
         &self,
         delegate: &dyn DapDelegate,

crates/dap_adapters/src/ruby.rs

@@ -6,8 +6,7 @@ use dap::{
         self, DapDelegate, DebugAdapter, DebugAdapterBinary, DebugAdapterName, DebugTaskDefinition,
     },
 };
-use gpui::{AsyncApp, SharedString};
-use language::LanguageName;
+use gpui::AsyncApp;
 use std::path::PathBuf;
 use util::command::new_smol_command;
 
@@ -26,10 +25,6 @@ impl DebugAdapter for RubyDebugAdapter {
         DebugAdapterName(Self::ADAPTER_NAME.into())
     }
 
-    fn adapter_language_name(&self) -> Option<LanguageName> {
-        Some(SharedString::new_static("Ruby").into())
-    }
-
     async fn get_binary(
         &self,
         delegate: &dyn DapDelegate,
@@ -67,7 +62,7 @@ impl DebugAdapter for RubyDebugAdapter {
         let tcp_connection = definition.tcp_connection.clone().unwrap_or_default();
         let (host, port, timeout) = crate::configure_tcp_connection(tcp_connection).await?;
 
-        let DebugRequest::Launch(launch) = definition.request.clone() else {
+        let DebugRequest::Launch(mut launch) = definition.request.clone() else {
             anyhow::bail!("rdbg does not yet support attaching");
         };
 
@@ -76,6 +71,12 @@ impl DebugAdapter for RubyDebugAdapter {
             format!("--port={}", port),
             format!("--host={}", host),
         ];
+        if launch.args.is_empty() {
+            let program = launch.program.clone();
+            let mut split = program.split(" ");
+            launch.program = split.next().unwrap().to_string();
+            launch.args = split.map(|s| s.to_string()).collect();
+        }
         if delegate.which(launch.program.as_ref()).is_some() {
             arguments.push("--command".to_string())
         }

crates/debug_adapter_extension/Cargo.toml

@@ -1,20 +0,0 @@
-[package]
-name = "debug_adapter_extension"
-version = "0.1.0"
-license = "GPL-3.0-or-later"
-publish.workspace = true
-edition.workspace = true
-
-[dependencies]
-anyhow.workspace = true
-async-trait.workspace = true
-dap.workspace = true
-extension.workspace = true
-gpui.workspace = true
-workspace-hack = { version = "0.1", path = "../../tooling/workspace-hack" }
-
-[lints]
-workspace = true
-
-[lib]
-path = "src/debug_adapter_extension.rs"

crates/debug_adapter_extension/LICENSE-GPL

@@ -1 +0,0 @@
-../../LICENSE-GPL

crates/debug_adapter_extension/src/debug_adapter_extension.rs

@@ -1,40 +0,0 @@
-mod extension_dap_adapter;
-
-use std::sync::Arc;
-
-use dap::DapRegistry;
-use extension::{ExtensionDebugAdapterProviderProxy, ExtensionHostProxy};
-use extension_dap_adapter::ExtensionDapAdapter;
-use gpui::App;
-
-pub fn init(extension_host_proxy: Arc<ExtensionHostProxy>, cx: &mut App) {
-    let language_server_registry_proxy = DebugAdapterRegistryProxy::new(cx);
-    extension_host_proxy.register_debug_adapter_proxy(language_server_registry_proxy);
-}
-
-#[derive(Clone)]
-struct DebugAdapterRegistryProxy {
-    debug_adapter_registry: DapRegistry,
-}
-
-impl DebugAdapterRegistryProxy {
-    fn new(cx: &mut App) -> Self {
-        Self {
-            debug_adapter_registry: DapRegistry::global(cx).clone(),
-        }
-    }
-}
-
-impl ExtensionDebugAdapterProviderProxy for DebugAdapterRegistryProxy {
-    fn register_debug_adapter(
-        &self,
-        extension: Arc<dyn extension::Extension>,
-        debug_adapter_name: Arc<str>,
-    ) {
-        self.debug_adapter_registry
-            .add_adapter(Arc::new(ExtensionDapAdapter::new(
-                extension,
-                debug_adapter_name,
-            )));
-    }
-}

crates/debug_adapter_extension/src/extension_dap_adapter.rs

@@ -1,49 +0,0 @@
-use std::{path::PathBuf, sync::Arc};
-
-use anyhow::Result;
-use async_trait::async_trait;
-use dap::adapters::{
-    DapDelegate, DebugAdapter, DebugAdapterBinary, DebugAdapterName, DebugTaskDefinition,
-};
-use extension::Extension;
-use gpui::AsyncApp;
-
-pub(crate) struct ExtensionDapAdapter {
-    extension: Arc<dyn Extension>,
-    debug_adapter_name: Arc<str>,
-}
-
-impl ExtensionDapAdapter {
-    pub(crate) fn new(
-        extension: Arc<dyn extension::Extension>,
-        debug_adapter_name: Arc<str>,
-    ) -> Self {
-        Self {
-            extension,
-            debug_adapter_name,
-        }
-    }
-}
-
-#[async_trait(?Send)]
-impl DebugAdapter for ExtensionDapAdapter {
-    fn name(&self) -> DebugAdapterName {
-        self.debug_adapter_name.as_ref().into()
-    }
-
-    async fn get_binary(
-        &self,
-        _: &dyn DapDelegate,
-        config: &DebugTaskDefinition,
-        user_installed_path: Option<PathBuf>,
-        _cx: &mut AsyncApp,
-    ) -> Result<DebugAdapterBinary> {
-        self.extension
-            .get_dap_binary(
-                self.debug_adapter_name.clone(),
-                config.clone(),
-                user_installed_path,
-            )
-            .await
-    }
-}

crates/debugger_tools/src/dap_log.rs

@@ -684,7 +684,7 @@ impl Render for DapLogView {
     }
 }
 
-actions!(dev, [OpenDebugAdapterLogs]);
+actions!(debug, [OpenDebuggerAdapterLogs]);
 
 pub fn init(cx: &mut App) {
     let log_store = cx.new(|cx| LogStore::new(cx));
@@ -702,7 +702,7 @@ pub fn init(cx: &mut App) {
         }
 
         let log_store = log_store.clone();
-        workspace.register_action(move |workspace, _: &OpenDebugAdapterLogs, window, cx| {
+        workspace.register_action(move |workspace, _: &OpenDebuggerAdapterLogs, window, cx| {
             let project = workspace.project().read(cx);
             if project.is_local() {
                 workspace.add_item_to_active_pane(

crates/debugger_ui/Cargo.toml

@@ -36,7 +36,6 @@ dap_adapters = { workspace = true, optional = true }
 db.workspace = true
 editor.workspace = true
 feature_flags.workspace = true
-file_icons.workspace = true
 futures.workspace = true
 fuzzy.workspace = true
 gpui.workspace = true
@@ -52,7 +51,6 @@ rpc.workspace = true
 serde.workspace = true
 serde_json.workspace = true
 settings.workspace = true
-shlex.workspace = true
 sysinfo.workspace = true
 task.workspace = true
 tasks_ui.workspace = true

crates/debugger_ui/src/debugger_panel.rs

@@ -1,11 +1,9 @@
 use crate::persistence::DebuggerPaneItem;
 use crate::session::DebugSession;
-use crate::session::running::RunningState;
 use crate::{
     ClearAllBreakpoints, Continue, Detach, FocusBreakpointList, FocusConsole, FocusFrames,
-    FocusLoadedSources, FocusModules, FocusTerminal, FocusVariables, Pause, Restart,
-    ShowStackTrace, StepBack, StepInto, StepOut, StepOver, Stop, ToggleIgnoreBreakpoints,
-    persistence,
+    FocusLoadedSources, FocusModules, FocusTerminal, FocusVariables, Pause, Restart, StepBack,
+    StepInto, StepOut, StepOver, Stop, ToggleIgnoreBreakpoints, persistence,
 };
 use anyhow::{Result, anyhow};
 use command_palette_hooks::CommandPaletteFilter;
@@ -24,14 +22,14 @@ use gpui::{
 
 use language::Buffer;
 use project::debugger::session::{Session, SessionStateEvent};
-use project::{Fs, ProjectPath, WorktreeId};
+use project::{Fs, WorktreeId};
 use project::{Project, debugger::session::ThreadStatus};
 use rpc::proto::{self};
 use settings::Settings;
 use std::any::TypeId;
 use std::sync::Arc;
 use task::{DebugScenario, TaskContext};
-use ui::{ContextMenu, Divider, Tooltip, prelude::*};
+use ui::{ContextMenu, Divider, DropdownMenu, Tooltip, prelude::*};
 use workspace::SplitDirection;
 use workspace::{
     Pane, Workspace,
@@ -69,7 +67,11 @@ pub struct DebugPanel {
 }
 
 impl DebugPanel {
-    pub fn new(workspace: &Workspace, cx: &mut Context<Workspace>) -> Entity<Self> {
+    pub fn new(
+        workspace: &Workspace,
+        _window: &mut Window,
+        cx: &mut Context<Workspace>,
+    ) -> Entity<Self> {
         cx.new(|cx| {
             let project = workspace.project().clone();
 
@@ -88,20 +90,7 @@ impl DebugPanel {
         })
     }
 
-    pub(crate) fn sessions(&self) -> Vec<Entity<DebugSession>> {
-        self.sessions.clone()
-    }
-
-    pub fn active_session(&self) -> Option<Entity<DebugSession>> {
-        self.active_session.clone()
-    }
-
-    pub(crate) fn running_state(&self, cx: &mut App) -> Option<Entity<RunningState>> {
-        self.active_session()
-            .map(|session| session.read(cx).running_state().clone())
-    }
-
-    pub(crate) fn filter_action_types(&self, cx: &mut App) {
+    fn filter_action_types(&self, cx: &mut App) {
         let (has_active_session, supports_restart, support_step_back, status) = self
             .active_session()
             .map(|item| {
@@ -130,7 +119,6 @@ impl DebugPanel {
             TypeId::of::<StepOver>(),
             TypeId::of::<StepInto>(),
             TypeId::of::<StepOut>(),
-            TypeId::of::<ShowStackTrace>(),
             TypeId::of::<editor::actions::DebuggerRunToCursor>(),
             TypeId::of::<editor::actions::DebuggerEvaluateSelectedText>(),
         ];
@@ -182,8 +170,8 @@ impl DebugPanel {
         cx: &mut AsyncWindowContext,
     ) -> Task<Result<Entity<Self>>> {
         cx.spawn(async move |cx| {
-            workspace.update(cx, |workspace, cx| {
-                let debug_panel = DebugPanel::new(workspace, cx);
+            workspace.update_in(cx, |workspace, window, cx| {
+                let debug_panel = DebugPanel::new(workspace, window, cx);
 
                 workspace.register_action(|workspace, _: &ClearAllBreakpoints, _, cx| {
                     workspace.project().read(cx).breakpoint_store().update(
@@ -230,18 +218,6 @@ impl DebugPanel {
                 cx,
             )
         });
-        if let Some(inventory) = self
-            .project
-            .read(cx)
-            .task_store()
-            .read(cx)
-            .task_inventory()
-            .cloned()
-        {
-            inventory.update(cx, |inventory, _| {
-                inventory.scenario_scheduled(scenario.clone());
-            })
-        }
         let task = cx.spawn_in(window, {
             let session = session.clone();
             async move |this, cx| {
@@ -287,7 +263,7 @@ impl DebugPanel {
         .detach_and_log_err(cx);
     }
 
-    pub(crate) async fn register_session(
+    async fn register_session(
         this: WeakEntity<Self>,
         session: Entity<Session>,
         cx: &mut AsyncWindowContext,
@@ -356,7 +332,7 @@ impl DebugPanel {
         Ok(debug_session)
     }
 
-    pub(crate) fn handle_restart_request(
+    fn handle_restart_request(
         &mut self,
         mut curr_session: Entity<Session>,
         window: &mut Window,
@@ -430,12 +406,10 @@ impl DebugPanel {
         .detach_and_log_err(cx);
     }
 
-    pub(crate) fn close_session(
-        &mut self,
-        entity_id: EntityId,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) {
+    pub fn active_session(&self) -> Option<Entity<DebugSession>> {
+        self.active_session.clone()
+    }
+    fn close_session(&mut self, entity_id: EntityId, window: &mut Window, cx: &mut Context<Self>) {
         let Some(session) = self
             .sessions
             .iter()
@@ -489,8 +463,93 @@ impl DebugPanel {
         })
         .detach();
     }
+    fn sessions_drop_down_menu(
+        &self,
+        active_session: &Entity<DebugSession>,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> DropdownMenu {
+        let sessions = self.sessions.clone();
+        let weak = cx.weak_entity();
+        let label = active_session.read(cx).label_element(cx);
 
-    pub(crate) fn deploy_context_menu(
+        DropdownMenu::new_with_element(
+            "debugger-session-list",
+            label,
+            ContextMenu::build(window, cx, move |mut this, _, cx| {
+                let context_menu = cx.weak_entity();
+                for session in sessions.into_iter() {
+                    let weak_session = session.downgrade();
+                    let weak_session_id = weak_session.entity_id();
+
+                    this = this.custom_entry(
+                        {
+                            let weak = weak.clone();
+                            let context_menu = context_menu.clone();
+                            move |_, cx| {
+                                weak_session
+                                    .read_with(cx, |session, cx| {
+                                        let context_menu = context_menu.clone();
+                                        let id: SharedString =
+                                            format!("debug-session-{}", session.session_id(cx).0)
+                                                .into();
+                                        h_flex()
+                                            .w_full()
+                                            .group(id.clone())
+                                            .justify_between()
+                                            .child(session.label_element(cx))
+                                            .child(
+                                                IconButton::new(
+                                                    "close-debug-session",
+                                                    IconName::Close,
+                                                )
+                                                .visible_on_hover(id.clone())
+                                                .icon_size(IconSize::Small)
+                                                .on_click({
+                                                    let weak = weak.clone();
+                                                    move |_, window, cx| {
+                                                        weak.update(cx, |panel, cx| {
+                                                            panel.close_session(
+                                                                weak_session_id,
+                                                                window,
+                                                                cx,
+                                                            );
+                                                        })
+                                                        .ok();
+                                                        context_menu
+                                                            .update(cx, |this, cx| {
+                                                                this.cancel(
+                                                                    &Default::default(),
+                                                                    window,
+                                                                    cx,
+                                                                );
+                                                            })
+                                                            .ok();
+                                                    }
+                                                }),
+                                            )
+                                            .into_any_element()
+                                    })
+                                    .unwrap_or_else(|_| div().into_any_element())
+                            }
+                        },
+                        {
+                            let weak = weak.clone();
+                            move |window, cx| {
+                                weak.update(cx, |panel, cx| {
+                                    panel.activate_session(session.clone(), window, cx);
+                                })
+                                .ok();
+                            }
+                        },
+                    );
+                }
+                this
+            }),
+        )
+    }
+
+    fn deploy_context_menu(
         &mut self,
         position: Point<Pixels>,
         window: &mut Window,
@@ -541,11 +600,7 @@ impl DebugPanel {
         }
     }
 
-    pub(crate) fn top_controls_strip(
-        &mut self,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) -> Option<Div> {
+    fn top_controls_strip(&self, window: &mut Window, cx: &mut Context<Self>) -> Option<Div> {
         let active_session = self.active_session.clone();
         let focus_handle = self.focus_handle.clone();
         let is_side = self.position(window, cx).axis() == gpui::Axis::Horizontal;
@@ -585,12 +640,12 @@ impl DebugPanel {
                                 active_session
                                     .as_ref()
                                     .map(|session| session.read(cx).running_state()),
-                                |this, running_state| {
+                                |this, running_session| {
                                     let thread_status =
-                                        running_state.read(cx).thread_status(cx).unwrap_or(
+                                        running_session.read(cx).thread_status(cx).unwrap_or(
                                             project::debugger::session::ThreadStatus::Exited,
                                         );
-                                    let capabilities = running_state.read(cx).capabilities(cx);
+                                    let capabilities = running_session.read(cx).capabilities(cx);
                                     this.map(|this| {
                                         if thread_status == ThreadStatus::Running {
                                             this.child(
@@ -601,7 +656,7 @@ impl DebugPanel {
                                                 .icon_size(IconSize::XSmall)
                                                 .shape(ui::IconButtonShape::Square)
                                                 .on_click(window.listener_for(
-                                                    &running_state,
+                                                    &running_session,
                                                     |this, _, _window, cx| {
                                                         this.pause_thread(cx);
                                                     },
@@ -628,7 +683,7 @@ impl DebugPanel {
                                                 .icon_size(IconSize::XSmall)
                                                 .shape(ui::IconButtonShape::Square)
                                                 .on_click(window.listener_for(
-                                                    &running_state,
+                                                    &running_session,
                                                     |this, _, _window, cx| this.continue_thread(cx),
                                                 ))
                                                 .disabled(thread_status != ThreadStatus::Stopped)
@@ -652,7 +707,7 @@ impl DebugPanel {
                                             .icon_size(IconSize::XSmall)
                                             .shape(ui::IconButtonShape::Square)
                                             .on_click(window.listener_for(
-                                                &running_state,
+                                                &running_session,
                                                 |this, _, _window, cx| {
                                                     this.step_over(cx);
                                                 },
@@ -676,7 +731,7 @@ impl DebugPanel {
                                             .icon_size(IconSize::XSmall)
                                             .shape(ui::IconButtonShape::Square)
                                             .on_click(window.listener_for(
-                                                &running_state,
+                                                &running_session,
                                                 |this, _, _window, cx| {
                                                     this.step_out(cx);
                                                 },
@@ -703,7 +758,7 @@ impl DebugPanel {
                                         .icon_size(IconSize::XSmall)
                                         .shape(ui::IconButtonShape::Square)
                                         .on_click(window.listener_for(
-                                            &running_state,
+                                            &running_session,
                                             |this, _, _window, cx| {
                                                 this.step_in(cx);
                                             },
@@ -753,7 +808,7 @@ impl DebugPanel {
                                                 || thread_status == ThreadStatus::Ended,
                                         )
                                         .on_click(window.listener_for(
-                                            &running_state,
+                                            &running_session,
                                             |this, _, _window, cx| {
                                                 this.toggle_ignore_breakpoints(cx);
                                             },
@@ -776,7 +831,7 @@ impl DebugPanel {
                                         IconButton::new("debug-restart", IconName::DebugRestart)
                                             .icon_size(IconSize::XSmall)
                                             .on_click(window.listener_for(
-                                                &running_state,
+                                                &running_session,
                                                 |this, _, _window, cx| {
                                                     this.restart_session(cx);
                                                 },
@@ -798,7 +853,7 @@ impl DebugPanel {
                                         IconButton::new("debug-stop", IconName::Power)
                                             .icon_size(IconSize::XSmall)
                                             .on_click(window.listener_for(
-                                                &running_state,
+                                                &running_session,
                                                 |this, _, _window, cx| {
                                                     this.stop_thread(cx);
                                                 },
@@ -832,7 +887,7 @@ impl DebugPanel {
                                         IconButton::new("debug-disconnect", IconName::DebugDetach)
                                             .icon_size(IconSize::XSmall)
                                             .on_click(window.listener_for(
-                                                &running_state,
+                                                &running_session,
                                                 |this, _, _, cx| {
                                                     this.detach_client(cx);
                                                 },
@@ -866,42 +921,30 @@ impl DebugPanel {
                                     .as_ref()
                                     .map(|session| session.read(cx).running_state())
                                     .cloned(),
-                                |this, running_state| {
-                                    this.children({
-                                        let running_state = running_state.clone();
-                                        let threads =
-                                            running_state.update(cx, |running_state, cx| {
-                                                let session = running_state.session();
-                                                session
-                                                    .update(cx, |session, cx| session.threads(cx))
-                                            });
-
-                                        self.render_thread_dropdown(
-                                            &running_state,
-                                            threads,
-                                            window,
-                                            cx,
-                                        )
-                                    })
+                                |this, session| {
+                                    this.child(
+                                        session.update(cx, |this, cx| {
+                                            this.thread_dropdown(window, cx)
+                                        }),
+                                    )
                                     .when(!is_side, |this| this.gap_2().child(Divider::vertical()))
                                 },
                             ),
                         )
                         .child(
                             h_flex()
-                                .children(self.render_session_menu(
-                                    self.active_session(),
-                                    self.running_state(cx),
-                                    window,
-                                    cx,
-                                ))
+                                .when_some(active_session.as_ref(), |this, session| {
+                                    let context_menu =
+                                        self.sessions_drop_down_menu(session, window, cx);
+                                    this.child(context_menu).gap_2().child(Divider::vertical())
+                                })
                                 .when(!is_side, |this| this.child(new_session_button())),
                         ),
                 ),
         )
     }
 
-    pub(crate) fn activate_pane_in_direction(
+    fn activate_pane_in_direction(
         &mut self,
         direction: SplitDirection,
         window: &mut Window,
@@ -916,7 +959,7 @@ impl DebugPanel {
         }
     }
 
-    pub(crate) fn activate_item(
+    fn activate_item(
         &mut self,
         item: DebuggerPaneItem,
         window: &mut Window,
@@ -931,7 +974,7 @@ impl DebugPanel {
         }
     }
 
-    pub(crate) fn activate_session(
+    fn activate_session(
         &mut self,
         session_item: Entity<DebugSession>,
         window: &mut Window,
@@ -944,7 +987,7 @@ impl DebugPanel {
                 this.go_to_selected_stack_frame(window, cx);
             });
         });
-        self.active_session = Some(session_item.clone());
+        self.active_session = Some(session_item);
         cx.notify();
     }
 
@@ -954,7 +997,7 @@ impl DebugPanel {
         worktree_id: WorktreeId,
         window: &mut Window,
         cx: &mut App,
-    ) -> Task<Result<ProjectPath>> {
+    ) -> Task<Result<()>> {
         self.workspace
             .update(cx, |workspace, cx| {
                 let Some(mut path) = workspace.absolute_path_of_worktree(worktree_id, cx) else {
@@ -963,26 +1006,23 @@ impl DebugPanel {
 
                 let serialized_scenario = serde_json::to_value(scenario);
 
+                path.push(paths::local_debug_file_relative_path());
+
                 cx.spawn_in(window, async move |workspace, cx| {
                     let serialized_scenario = serialized_scenario?;
+                    let path = path.as_path();
                     let fs =
                         workspace.update(cx, |workspace, _| workspace.app_state().fs.clone())?;
 
-                    path.push(paths::local_settings_folder_relative_path());
-                    if !fs.is_dir(path.as_path()).await {
-                        fs.create_dir(path.as_path()).await?;
-                    }
-                    path.pop();
-
-                    path.push(paths::local_debug_file_relative_path());
-                    let path = path.as_path();
-
                     if !fs.is_file(path).await {
                         let content =
                             serde_json::to_string_pretty(&serde_json::Value::Array(vec![
                                 serialized_scenario,
                             ]))?;
 
+                        if let Some(parent) = path.parent() {
+                            fs.create_dir(parent).await.ok();
+                        }
                         fs.create_file(path, Default::default()).await?;
                         fs.save(path, &content.into(), Default::default()).await?;
                     } else {
@@ -997,19 +1037,21 @@ impl DebugPanel {
                         .await?;
                     }
 
-                    workspace.update(cx, |workspace, cx| {
+                    workspace.update_in(cx, |workspace, window, cx| {
                         if let Some(project_path) = workspace
                             .project()
                             .read(cx)
                             .project_path_for_absolute_path(&path, cx)
                         {
-                            Ok(project_path)
+                            workspace.open_path(project_path, None, true, window, cx)
                         } else {
-                            Err(anyhow!(
+                            Task::ready(Err(anyhow!(
                                 "Couldn't get project path for .zed/debug.json in active worktree"
-                            ))
+                            )))
                         }
-                    })?
+                    })?.await?;
+
+                    anyhow::Ok(())
                 })
             })
             .unwrap_or_else(|err| Task::ready(Err(err)))
@@ -1076,7 +1118,7 @@ impl Panel for DebugPanel {
     }
 
     fn set_size(&mut self, size: Option<Pixels>, _window: &mut Window, _cx: &mut Context<Self>) {
-        self.size = size.unwrap_or(px(300.));
+        self.size = size.unwrap();
     }
 
     fn remote_id() -> Option<proto::PanelId> {

crates/debugger_ui/src/debugger_ui.rs

@@ -7,17 +7,14 @@ use new_session_modal::NewSessionModal;
 use project::debugger::{self, breakpoint_store::SourceBreakpoint};
 use session::DebugSession;
 use settings::Settings;
-use stack_trace_view::StackTraceView;
 use util::maybe;
-use workspace::{ItemHandle, ShutdownDebugAdapters, Workspace};
+use workspace::{ShutdownDebugAdapters, Workspace};
 
 pub mod attach_modal;
 pub mod debugger_panel;
-mod dropdown_menus;
 mod new_session_modal;
 mod persistence;
 pub(crate) mod session;
-mod stack_trace_view;
 
 #[cfg(any(test, feature = "test-support"))]
 pub mod tests;
@@ -44,7 +41,6 @@ actions!(
         FocusModules,
         FocusLoadedSources,
         FocusTerminal,
-        ShowStackTrace,
     ]
 );
 
@@ -150,38 +146,6 @@ pub fn init(cx: &mut App) {
                         })
                     },
                 )
-                .register_action(
-                    |workspace: &mut Workspace, _: &ShowStackTrace, window, cx| {
-                        let Some(debug_panel) = workspace.panel::<DebugPanel>(cx) else {
-                            return;
-                        };
-
-                        if let Some(existing) = workspace.item_of_type::<StackTraceView>(cx) {
-                            let is_active = workspace
-                                .active_item(cx)
-                                .is_some_and(|item| item.item_id() == existing.item_id());
-                            workspace.activate_item(&existing, true, !is_active, window, cx);
-                        } else {
-                            let Some(active_session) = debug_panel.read(cx).active_session() else {
-                                return;
-                            };
-
-                            let project = workspace.project();
-
-                            let stack_trace_view = active_session.update(cx, |session, cx| {
-                                session.stack_trace_view(project, window, cx).clone()
-                            });
-
-                            workspace.add_item_to_active_pane(
-                                Box::new(stack_trace_view),
-                                None,
-                                true,
-                                window,
-                                cx,
-                            );
-                        }
-                    },
-                )
                 .register_action(|workspace: &mut Workspace, _: &Start, window, cx| {
                     NewSessionModal::show(workspace, window, cx);
                 });

crates/debugger_ui/src/dropdown_menus.rs

@@ -1,186 +0,0 @@
-use gpui::Entity;
-use project::debugger::session::{ThreadId, ThreadStatus};
-use ui::{ContextMenu, DropdownMenu, DropdownStyle, Indicator, prelude::*};
-
-use crate::{
-    debugger_panel::DebugPanel,
-    session::{DebugSession, running::RunningState},
-};
-
-impl DebugPanel {
-    fn dropdown_label(label: impl Into<SharedString>) -> Label {
-        Label::new(label).size(LabelSize::Small)
-    }
-
-    pub fn render_session_menu(
-        &mut self,
-        active_session: Option<Entity<DebugSession>>,
-        running_state: Option<Entity<RunningState>>,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) -> Option<impl IntoElement> {
-        if let Some(running_state) = running_state {
-            let sessions = self.sessions().clone();
-            let weak = cx.weak_entity();
-            let running_state = running_state.read(cx);
-            let label = if let Some(active_session) = active_session {
-                active_session.read(cx).session(cx).read(cx).label()
-            } else {
-                SharedString::new_static("Unknown Session")
-            };
-
-            let is_terminated = running_state.session().read(cx).is_terminated();
-            let session_state_indicator = {
-                if is_terminated {
-                    Some(Indicator::dot().color(Color::Error))
-                } else {
-                    match running_state.thread_status(cx).unwrap_or_default() {
-                        project::debugger::session::ThreadStatus::Stopped => {
-                            Some(Indicator::dot().color(Color::Conflict))
-                        }
-                        _ => Some(Indicator::dot().color(Color::Success)),
-                    }
-                }
-            };
-
-            let trigger = h_flex()
-                .gap_2()
-                .when_some(session_state_indicator, |this, indicator| {
-                    this.child(indicator)
-                })
-                .justify_between()
-                .child(
-                    DebugPanel::dropdown_label(label)
-                        .when(is_terminated, |this| this.strikethrough()),
-                )
-                .into_any_element();
-
-            Some(
-                DropdownMenu::new_with_element(
-                    "debugger-session-list",
-                    trigger,
-                    ContextMenu::build(window, cx, move |mut this, _, cx| {
-                        let context_menu = cx.weak_entity();
-                        for session in sessions.into_iter() {
-                            let weak_session = session.downgrade();
-                            let weak_session_id = weak_session.entity_id();
-
-                            this = this.custom_entry(
-                                {
-                                    let weak = weak.clone();
-                                    let context_menu = context_menu.clone();
-                                    move |_, cx| {
-                                        weak_session
-                                            .read_with(cx, |session, cx| {
-                                                let context_menu = context_menu.clone();
-                                                let id: SharedString = format!(
-                                                    "debug-session-{}",
-                                                    session.session_id(cx).0
-                                                )
-                                                .into();
-                                                h_flex()
-                                                    .w_full()
-                                                    .group(id.clone())
-                                                    .justify_between()
-                                                    .child(session.label_element(cx))
-                                                    .child(
-                                                        IconButton::new(
-                                                            "close-debug-session",
-                                                            IconName::Close,
-                                                        )
-                                                        .visible_on_hover(id.clone())
-                                                        .icon_size(IconSize::Small)
-                                                        .on_click({
-                                                            let weak = weak.clone();
-                                                            move |_, window, cx| {
-                                                                weak.update(cx, |panel, cx| {
-                                                                    panel.close_session(
-                                                                        weak_session_id,
-                                                                        window,
-                                                                        cx,
-                                                                    );
-                                                                })
-                                                                .ok();
-                                                                context_menu
-                                                                    .update(cx, |this, cx| {
-                                                                        this.cancel(
-                                                                            &Default::default(),
-                                                                            window,
-                                                                            cx,
-                                                                        );
-                                                                    })
-                                                                    .ok();
-                                                            }
-                                                        }),
-                                                    )
-                                                    .into_any_element()
-                                            })
-                                            .unwrap_or_else(|_| div().into_any_element())
-                                    }
-                                },
-                                {
-                                    let weak = weak.clone();
-                                    move |window, cx| {
-                                        weak.update(cx, |panel, cx| {
-                                            panel.activate_session(session.clone(), window, cx);
-                                        })
-                                        .ok();
-                                    }
-                                },
-                            );
-                        }
-                        this
-                    }),
-                )
-                .style(DropdownStyle::Ghost),
-            )
-        } else {
-            None
-        }
-    }
-
-    pub(crate) fn render_thread_dropdown(
-        &self,
-        running_state: &Entity<RunningState>,
-        threads: Vec<(dap::Thread, ThreadStatus)>,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) -> Option<DropdownMenu> {
-        let running_state = running_state.clone();
-        let running_state_read = running_state.read(cx);
-        let thread_id = running_state_read.thread_id();
-        let session = running_state_read.session();
-        let session_id = session.read(cx).session_id();
-        let session_terminated = session.read(cx).is_terminated();
-        let selected_thread_name = threads
-            .iter()
-            .find(|(thread, _)| thread_id.map(|id| id.0) == Some(thread.id))
-            .map(|(thread, _)| thread.name.clone());
-
-        if let Some(selected_thread_name) = selected_thread_name {
-            let trigger = DebugPanel::dropdown_label(selected_thread_name).into_any_element();
-            Some(
-                DropdownMenu::new_with_element(
-                    ("thread-list", session_id.0),
-                    trigger,
-                    ContextMenu::build_eager(window, cx, move |mut this, _, _| {
-                        for (thread, _) in threads {
-                            let running_state = running_state.clone();
-                            let thread_id = thread.id;
-                            this = this.entry(thread.name, None, move |window, cx| {
-                                running_state.update(cx, |running_state, cx| {
-                                    running_state.select_thread(ThreadId(thread_id), window, cx);
-                                });
-                            });
-                        }
-                        this
-                    }),
-                )
-                .disabled(session_terminated)
-                .style(DropdownStyle::Ghost),
-            )
-        } else {
-            None
-        }
-    }
-}

crates/debugger_ui/src/new_session_modal.rs

@@ -1,15 +1,11 @@
-use collections::FxHashMap;
-use language::LanguageRegistry;
 use std::{
     borrow::Cow,
     ops::Not,
     path::{Path, PathBuf},
     sync::Arc,
-    time::Duration,
     usize,
 };
 
-use anyhow::Result;
 use dap::{
     DapRegistry, DebugRequest,
     adapters::{DebugAdapterName, DebugTaskDefinition},
@@ -17,32 +13,26 @@ use dap::{
 use editor::{Editor, EditorElement, EditorStyle};
 use fuzzy::{StringMatch, StringMatchCandidate};
 use gpui::{
-    Animation, AnimationExt as _, App, AppContext, DismissEvent, Entity, EventEmitter, FocusHandle,
-    Focusable, Render, Subscription, TextStyle, Transformation, WeakEntity, percentage,
+    App, AppContext, DismissEvent, Entity, EventEmitter, FocusHandle, Focusable, Render,
+    Subscription, TextStyle, WeakEntity,
 };
 use picker::{Picker, PickerDelegate, highlighted_match_with_paths::HighlightedMatch};
-use project::{ProjectPath, TaskContexts, TaskSourceKind, task_store::TaskStore};
+use project::{TaskContexts, TaskSourceKind, task_store::TaskStore};
 use settings::Settings;
 use task::{DebugScenario, LaunchRequest};
 use theme::ThemeSettings;
 use ui::{
     ActiveTheme, Button, ButtonCommon, ButtonSize, CheckboxWithLabel, Clickable, Color, Context,
-    ContextMenu, Disableable, DropdownMenu, FluentBuilder, Icon, IconButton, IconName, IconSize,
-    InteractiveElement, IntoElement, Label, LabelCommon as _, ListItem, ListItemSpacing,
-    ParentElement, RenderOnce, SharedString, Styled, StyledExt, ToggleButton, ToggleState,
-    Toggleable, Window, div, h_flex, relative, rems, v_flex,
+    ContextMenu, Disableable, DropdownMenu, FluentBuilder, Icon, IconName, InteractiveElement,
+    IntoElement, Label, LabelCommon as _, ListItem, ListItemSpacing, ParentElement, RenderOnce,
+    SharedString, Styled, StyledExt, ToggleButton, ToggleState, Toggleable, Window, div, h_flex,
+    relative, rems, v_flex,
 };
 use util::ResultExt;
 use workspace::{ModalView, Workspace, pane};
 
 use crate::{attach_modal::AttachModal, debugger_panel::DebugPanel};
 
-enum SaveScenarioState {
-    Saving,
-    Saved(ProjectPath),
-    Failed(SharedString),
-}
-
 pub(super) struct NewSessionModal {
     workspace: WeakEntity<Workspace>,
     debug_panel: WeakEntity<DebugPanel>,
@@ -51,7 +41,7 @@ pub(super) struct NewSessionModal {
     attach_mode: Entity<AttachMode>,
     custom_mode: Entity<CustomMode>,
     debugger: Option<DebugAdapterName>,
-    save_scenario_state: Option<SaveScenarioState>,
+    task_contexts: Arc<TaskContexts>,
     _subscriptions: [Subscription; 2],
 }
 
@@ -83,9 +73,16 @@ impl NewSessionModal {
             return;
         };
         let task_store = workspace.project().read(cx).task_store().clone();
-        let languages = workspace.app_state().languages.clone();
 
         cx.spawn_in(window, async move |workspace, cx| {
+            let task_contexts = Arc::from(
+                workspace
+                    .update_in(cx, |workspace, window, cx| {
+                        tasks_ui::task_contexts(workspace, window, cx)
+                    })?
+                    .await,
+            );
+
             workspace.update_in(cx, |workspace, window, cx| {
                 let workspace_handle = workspace.weak_handle();
                 workspace.toggle_modal(window, cx, |window, cx| {
@@ -93,7 +90,12 @@ impl NewSessionModal {
 
                     let launch_picker = cx.new(|cx| {
                         Picker::uniform_list(
-                            DebugScenarioDelegate::new(debug_panel.downgrade(), task_store),
+                            DebugScenarioDelegate::new(
+                                debug_panel.downgrade(),
+                                workspace_handle.clone(),
+                                task_store,
+                                task_contexts.clone(),
+                            ),
                             window,
                             cx,
                         )
@@ -114,42 +116,6 @@ impl NewSessionModal {
 
                     let custom_mode = CustomMode::new(None, window, cx);
 
-                    cx.spawn_in(window, {
-                        let workspace_handle = workspace_handle.clone();
-                        async move |this, cx| {
-                            let task_contexts = workspace_handle
-                                .update_in(cx, |workspace, window, cx| {
-                                    tasks_ui::task_contexts(workspace, window, cx)
-                                })?
-                                .await;
-
-                            this.update_in(cx, |this, window, cx| {
-                                if let Some(active_cwd) = task_contexts
-                                    .active_context()
-                                    .and_then(|context| context.cwd.clone())
-                                {
-                                    this.custom_mode.update(cx, |custom, cx| {
-                                        custom.load(active_cwd, window, cx);
-                                    });
-
-                                    this.debugger = None;
-                                }
-
-                                this.launch_picker.update(cx, |picker, cx| {
-                                    picker.delegate.task_contexts_loaded(
-                                        task_contexts,
-                                        languages,
-                                        window,
-                                        cx,
-                                    );
-                                    picker.refresh(window, cx);
-                                    cx.notify();
-                                });
-                            })
-                        }
-                    })
-                    .detach();
-
                     Self {
                         launch_picker,
                         attach_mode,
@@ -158,7 +124,7 @@ impl NewSessionModal {
                         mode: NewSessionMode::Launch,
                         debug_panel: debug_panel.downgrade(),
                         workspace: workspace_handle,
-                        save_scenario_state: None,
+                        task_contexts,
                         _subscriptions,
                     }
                 });
@@ -169,7 +135,7 @@ impl NewSessionModal {
         .detach();
     }
 
-    fn render_mode(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl ui::IntoElement {
+    fn render_mode(&self, window: &mut Window, cx: &mut Context<Self>) -> impl ui::IntoElement {
         let dap_menu = self.adapter_drop_down_menu(window, cx);
         match self.mode {
             NewSessionMode::Attach => self.attach_mode.update(cx, |this, cx| {
@@ -224,6 +190,8 @@ impl NewSessionModal {
 
     fn start_new_session(&self, window: &mut Window, cx: &mut Context<Self>) {
         let Some(debugger) = self.debugger.as_ref() else {
+            // todo(debugger): show in UI.
+            log::error!("No debugger selected");
             return;
         };
 
@@ -240,12 +208,10 @@ impl NewSessionModal {
         };
 
         let debug_panel = self.debug_panel.clone();
-        let Some(task_contexts) = self.task_contexts(cx) else {
-            return;
-        };
-        let task_context = task_contexts.active_context().cloned().unwrap_or_default();
-        let worktree_id = task_contexts.worktree();
+        let task_contexts = self.task_contexts.clone();
         cx.spawn_in(window, async move |this, cx| {
+            let task_context = task_contexts.active_context().cloned().unwrap_or_default();
+            let worktree_id = task_contexts.worktree();
             debug_panel.update_in(cx, |debug_panel, window, cx| {
                 debug_panel.start_session(config, task_context, None, worktree_id, window, cx)
             })?;
@@ -253,7 +219,7 @@ impl NewSessionModal {
                 cx.emit(DismissEvent);
             })
             .ok();
-            Result::<_, anyhow::Error>::Ok(())
+            anyhow::Result::<_, anyhow::Error>::Ok(())
         })
         .detach_and_log_err(cx);
     }
@@ -279,55 +245,33 @@ impl NewSessionModal {
             cx.notify();
         })
     }
-
-    fn task_contexts<'a>(&self, cx: &'a mut Context<Self>) -> Option<&'a TaskContexts> {
-        self.launch_picker.read(cx).delegate.task_contexts.as_ref()
-    }
-
     fn adapter_drop_down_menu(
-        &mut self,
+        &self,
         window: &mut Window,
         cx: &mut Context<Self>,
     ) -> ui::DropdownMenu {
         let workspace = self.workspace.clone();
         let weak = cx.weak_entity();
-        let active_buffer = self.task_contexts(cx).and_then(|tc| {
-            tc.active_item_context
-                .as_ref()
-                .and_then(|aic| aic.1.as_ref().map(|l| l.buffer.clone()))
-        });
-
-        let active_buffer_language = active_buffer
-            .and_then(|buffer| buffer.read(cx).language())
-            .cloned();
-
-        let mut available_adapters = workspace
-            .update(cx, |_, cx| DapRegistry::global(cx).enumerate_adapters())
-            .unwrap_or_default();
-        if let Some(language) = active_buffer_language {
-            available_adapters.sort_by_key(|adapter| {
-                language
-                    .config()
-                    .debuggers
-                    .get_index_of(adapter.0.as_ref())
-                    .unwrap_or(usize::MAX)
-            });
-        }
-
-        if self.debugger.is_none() {
-            self.debugger = available_adapters.first().cloned();
-        }
-
         let label = self
             .debugger
             .as_ref()
             .map(|d| d.0.clone())
             .unwrap_or_else(|| SELECT_DEBUGGER_LABEL.clone());
+        let active_buffer_language = self
+            .task_contexts
+            .active_item_context
+            .as_ref()
+            .and_then(|item| {
+                item.1
+                    .as_ref()
+                    .and_then(|location| location.buffer.read(cx).language())
+            })
+            .cloned();
 
         DropdownMenu::new(
             "dap-adapter-picker",
             label,
-            ContextMenu::build(window, cx, move |mut menu, _, _| {
+            ContextMenu::build(window, cx, move |mut menu, _, cx| {
                 let setter_for_name = |name: DebugAdapterName| {
                     let weak = weak.clone();
                     move |window: &mut Window, cx: &mut App| {
@@ -342,10 +286,22 @@ impl NewSessionModal {
                     }
                 };
 
+                let mut available_adapters = workspace
+                    .update(cx, |_, cx| DapRegistry::global(cx).enumerate_adapters())
+                    .unwrap_or_default();
+                if let Some(language) = active_buffer_language {
+                    available_adapters.sort_by_key(|adapter| {
+                        language
+                            .config()
+                            .debuggers
+                            .get_index_of(adapter.0.as_ref())
+                            .unwrap_or(usize::MAX)
+                    });
+                }
+
                 for adapter in available_adapters.into_iter() {
                     menu = menu.entry(adapter.0.clone(), None, setter_for_name(adapter.clone()));
                 }
-
                 menu
             }),
         )
@@ -423,8 +379,6 @@ impl Render for NewSessionModal {
         window: &mut ui::Window,
         cx: &mut ui::Context<Self>,
     ) -> impl ui::IntoElement {
-        let this = cx.weak_entity().clone();
-
         v_flex()
             .size_full()
             .w(rems(34.))
@@ -530,151 +484,42 @@ impl Render for NewSessionModal {
                                 }
                             }),
                         ),
-                        NewSessionMode::Custom => h_flex()
-                            .child(
-                                Button::new("new-session-modal-back", "Save to .zed/debug.json...")
-                                    .on_click(cx.listener(|this, _, window, cx| {
-                                        let Some(save_scenario) = this
-                                            .debugger
-                                            .as_ref()
-                                            .and_then(|debugger| this.debug_scenario(&debugger, cx))
-                                            .zip(
-                                                this.task_contexts(cx)
-                                                    .and_then(|tcx| tcx.worktree()),
-                                            )
-                                            .and_then(|(scenario, worktree_id)| {
-                                                this.debug_panel
-                                                    .update(cx, |panel, cx| {
-                                                        panel.save_scenario(
-                                                            &scenario,
-                                                            worktree_id,
-                                                            window,
-                                                            cx,
-                                                        )
-                                                    })
-                                                    .ok()
-                                            })
-                                        else {
-                                            return;
-                                        };
-
-                                        this.save_scenario_state = Some(SaveScenarioState::Saving);
-
-                                        cx.spawn(async move |this, cx| {
-                                            let res = save_scenario.await;
-
-                                            this.update(cx, |this, _| match res {
-                                                Ok(saved_file) => {
-                                                    this.save_scenario_state =
-                                                        Some(SaveScenarioState::Saved(saved_file))
-                                                }
-                                                Err(error) => {
-                                                    this.save_scenario_state =
-                                                        Some(SaveScenarioState::Failed(
-                                                            error.to_string().into(),
-                                                        ))
-                                                }
-                                            })
-                                            .ok();
-
-                                            cx.background_executor()
-                                                .timer(Duration::from_secs(2))
-                                                .await;
-                                            this.update(cx, |this, _| {
-                                                this.save_scenario_state.take()
-                                            })
-                                            .ok();
+                        NewSessionMode::Custom => div().child(
+                            Button::new("new-session-modal-back", "Save to .zed/debug.json...")
+                                .on_click(cx.listener(|this, _, window, cx| {
+                                    let Some(save_scenario_task) = this
+                                        .debugger
+                                        .as_ref()
+                                        .and_then(|debugger| this.debug_scenario(&debugger, cx))
+                                        .zip(this.task_contexts.worktree())
+                                        .and_then(|(scenario, worktree_id)| {
+                                            this.debug_panel
+                                                .update(cx, |panel, cx| {
+                                                    panel.save_scenario(
+                                                        &scenario,
+                                                        worktree_id,
+                                                        window,
+                                                        cx,
+                                                    )
+                                                })
+                                                .ok()
                                         })
-                                        .detach();
-                                    }))
-                                    .disabled(
-                                        self.debugger.is_none()
-                                            || self
-                                                .custom_mode
-                                                .read(cx)
-                                                .program
-                                                .read(cx)
-                                                .is_empty(cx)
-                                            || self.save_scenario_state.is_some(),
-                                    ),
-                            )
-                            .when_some(self.save_scenario_state.as_ref(), {
-                                let this_entity = this.clone();
+                                    else {
+                                        return;
+                                    };
 
-                                move |this, save_state| match save_state {
-                                    SaveScenarioState::Saved(saved_path) => this.child(
-                                        IconButton::new(
-                                            "new-session-modal-go-to-file",
-                                            IconName::ArrowUpRight,
-                                        )
-                                        .icon_size(IconSize::Small)
-                                        .icon_color(Color::Muted)
-                                        .on_click({
-                                            let this_entity = this_entity.clone();
-                                            let saved_path = saved_path.clone();
-                                            move |_, window, cx| {
-                                                window
-                                                    .spawn(cx, {
-                                                        let this_entity = this_entity.clone();
-                                                        let saved_path = saved_path.clone();
-
-                                                        async move |cx| {
-                                                            this_entity
-                                                                .update_in(
-                                                                    cx,
-                                                                    |this, window, cx| {
-                                                                        this.workspace.update(
-                                                                            cx,
-                                                                            |workspace, cx| {
-                                                                                workspace.open_path(
-                                                                                    saved_path
-                                                                                        .clone(),
-                                                                                    None,
-                                                                                    true,
-                                                                                    window,
-                                                                                    cx,
-                                                                                )
-                                                                            },
-                                                                        )
-                                                                    },
-                                                                )??
-                                                                .await?;
-
-                                                            this_entity
-                                                                .update(cx, |_, cx| {
-                                                                    cx.emit(DismissEvent)
-                                                                })
-                                                                .ok();
-
-                                                            anyhow::Ok(())
-                                                        }
-                                                    })
-                                                    .detach();
-                                            }
-                                        }),
-                                    ),
-                                    SaveScenarioState::Saving => this.child(
-                                        Icon::new(IconName::Spinner)
-                                            .size(IconSize::Small)
-                                            .color(Color::Muted)
-                                            .with_animation(
-                                                "Spinner",
-                                                Animation::new(Duration::from_secs(3)).repeat(),
-                                                |icon, delta| {
-                                                    icon.transform(Transformation::rotate(
-                                                        percentage(delta),
-                                                    ))
-                                                },
-                                            ),
-                                    ),
-                                    SaveScenarioState::Failed(error_msg) => this.child(
-                                        IconButton::new("Failed Scenario Saved", IconName::X)
-                                            .icon_size(IconSize::Small)
-                                            .icon_color(Color::Error)
-                                            .tooltip(ui::Tooltip::text(error_msg.clone())),
-                                    ),
-                                }
-                            }),
+                                    cx.spawn(async move |this, cx| {
+                                        if save_scenario_task.await.is_ok() {
+                                            this.update(cx, |_, cx| cx.emit(DismissEvent)).ok();
+                                        }
+                                    })
+                                    .detach();
+                                }))
+                                .disabled(
+                                    self.debugger.is_none()
+                                        || self.custom_mode.read(cx).program.read(cx).is_empty(cx),
+                                ),
+                        ),
                     })
                     .child(
                         Button::new("debugger-spawn", "Start")
@@ -750,7 +595,7 @@ impl CustomMode {
 
         let program = cx.new(|cx| Editor::single_line(window, cx));
         program.update(cx, |this, cx| {
-            this.set_placeholder_text("Run", cx);
+            this.set_placeholder_text("Program path", cx);
 
             if let Some(past_program) = past_program {
                 this.set_text(past_program, window, cx);
@@ -770,49 +615,13 @@ impl CustomMode {
         })
     }
 
-    fn load(&mut self, cwd: PathBuf, window: &mut Window, cx: &mut App) {
-        self.cwd.update(cx, |editor, cx| {
-            if editor.is_empty(cx) {
-                editor.set_text(cwd.to_string_lossy(), window, cx);
-            }
-        });
-    }
-
     pub(super) fn debug_request(&self, cx: &App) -> task::LaunchRequest {
         let path = self.cwd.read(cx).text(cx);
-        if cfg!(windows) {
-            return task::LaunchRequest {
-                program: self.program.read(cx).text(cx),
-                cwd: path.is_empty().not().then(|| PathBuf::from(path)),
-                args: Default::default(),
-                env: Default::default(),
-            };
-        }
-        let command = self.program.read(cx).text(cx);
-        let mut args = shlex::split(&command).into_iter().flatten().peekable();
-        let mut env = FxHashMap::default();
-        while args.peek().is_some_and(|arg| arg.contains('=')) {
-            let arg = args.next().unwrap();
-            let (lhs, rhs) = arg.split_once('=').unwrap();
-            env.insert(lhs.to_string(), rhs.to_string());
-        }
-
-        let program = if let Some(program) = args.next() {
-            program
-        } else {
-            env = FxHashMap::default();
-            command
-        };
-
-        let args = args.collect::<Vec<_>>();
-
-        let (program, path) = resolve_paths(program, path);
-
         task::LaunchRequest {
-            program,
+            program: self.program.read(cx).text(cx),
             cwd: path.is_empty().not().then(|| PathBuf::from(path)),
-            args,
-            env,
+            args: Default::default(),
+            env: Default::default(),
         }
     }
 
@@ -827,6 +636,14 @@ impl CustomMode {
             .w_full()
             .gap_3()
             .track_focus(&self.program.focus_handle(cx))
+            .child(
+                div().child(
+                    Label::new("Program")
+                        .size(ui::LabelSize::Small)
+                        .color(Color::Muted),
+                ),
+            )
+            .child(render_editor(&self.program, window, cx))
             .child(
                 h_flex()
                     .child(
@@ -837,14 +654,10 @@ impl CustomMode {
                     .gap(ui::DynamicSpacing::Base08.rems(cx))
                     .child(adapter_menu),
             )
-            .child(render_editor(&self.program, window, cx))
-            .child(render_editor(&self.cwd, window, cx))
             .child(
                 CheckboxWithLabel::new(
                     "debugger-stop-on-entry",
-                    Label::new("Stop on Entry")
-                        .size(ui::LabelSize::Small)
-                        .color(Color::Muted),
+                    Label::new("Stop on Entry").size(ui::LabelSize::Small),
                     self.stop_on_entry,
                     {
                         let this = cx.weak_entity();
@@ -901,106 +714,33 @@ impl AttachMode {
 
 pub(super) struct DebugScenarioDelegate {
     task_store: Entity<TaskStore>,
-    candidates: Vec<(Option<TaskSourceKind>, DebugScenario)>,
+    candidates: Option<Vec<(TaskSourceKind, DebugScenario)>>,
     selected_index: usize,
     matches: Vec<StringMatch>,
     prompt: String,
     debug_panel: WeakEntity<DebugPanel>,
-    task_contexts: Option<TaskContexts>,
-    divider_index: Option<usize>,
-    last_used_candidate_index: Option<usize>,
+    workspace: WeakEntity<Workspace>,
+    task_contexts: Arc<TaskContexts>,
 }
 
 impl DebugScenarioDelegate {
-    pub(super) fn new(debug_panel: WeakEntity<DebugPanel>, task_store: Entity<TaskStore>) -> Self {
+    pub(super) fn new(
+        debug_panel: WeakEntity<DebugPanel>,
+        workspace: WeakEntity<Workspace>,
+        task_store: Entity<TaskStore>,
+        task_contexts: Arc<TaskContexts>,
+    ) -> Self {
         Self {
             task_store,
-            candidates: Vec::default(),
+            candidates: None,
             selected_index: 0,
             matches: Vec::new(),
             prompt: String::new(),
             debug_panel,
-            task_contexts: None,
-            divider_index: None,
-            last_used_candidate_index: None,
+            workspace,
+            task_contexts,
         }
     }
-
-    fn get_scenario_kind(
-        languages: &Arc<LanguageRegistry>,
-        dap_registry: &DapRegistry,
-        scenario: DebugScenario,
-    ) -> (Option<TaskSourceKind>, DebugScenario) {
-        let language_names = languages.language_names();
-        let language = dap_registry
-            .adapter_language(&scenario.adapter)
-            .map(|language| TaskSourceKind::Language {
-                name: language.into(),
-            });
-
-        let language = language.or_else(|| {
-            scenario
-                .request
-                .as_ref()
-                .and_then(|request| match request {
-                    DebugRequest::Launch(launch) => launch
-                        .program
-                        .rsplit_once(".")
-                        .and_then(|split| languages.language_name_for_extension(split.1))
-                        .map(|name| TaskSourceKind::Language { name: name.into() }),
-                    _ => None,
-                })
-                .or_else(|| {
-                    scenario.label.split_whitespace().find_map(|word| {
-                        language_names
-                            .iter()
-                            .find(|name| name.eq_ignore_ascii_case(word))
-                            .map(|name| TaskSourceKind::Language {
-                                name: name.to_owned().into(),
-                            })
-                    })
-                })
-        });
-
-        (language, scenario)
-    }
-
-    pub fn task_contexts_loaded(
-        &mut self,
-        task_contexts: TaskContexts,
-        languages: Arc<LanguageRegistry>,
-        _window: &mut Window,
-        cx: &mut Context<Picker<Self>>,
-    ) {
-        self.task_contexts = Some(task_contexts);
-
-        let (recent, scenarios) = self
-            .task_store
-            .update(cx, |task_store, cx| {
-                task_store.task_inventory().map(|inventory| {
-                    inventory.update(cx, |inventory, cx| {
-                        inventory.list_debug_scenarios(self.task_contexts.as_ref().unwrap(), cx)
-                    })
-                })
-            })
-            .unwrap_or_default();
-
-        if !recent.is_empty() {
-            self.last_used_candidate_index = Some(recent.len() - 1);
-        }
-
-        let dap_registry = cx.global::<DapRegistry>();
-
-        self.candidates = recent
-            .into_iter()
-            .map(|scenario| Self::get_scenario_kind(&languages, &dap_registry, scenario))
-            .chain(scenarios.into_iter().map(|(kind, scenario)| {
-                let (language, scenario) =
-                    Self::get_scenario_kind(&languages, &dap_registry, scenario);
-                (language.or(Some(kind)), scenario)
-            }))
-            .collect();
-    }
 }
 
 impl PickerDelegate for DebugScenarioDelegate {
@@ -1034,15 +774,53 @@ impl PickerDelegate for DebugScenarioDelegate {
         cx: &mut Context<picker::Picker<Self>>,
     ) -> gpui::Task<()> {
         let candidates = self.candidates.clone();
+        let workspace = self.workspace.clone();
+        let task_store = self.task_store.clone();
 
         cx.spawn_in(window, async move |picker, cx| {
-            let candidates: Vec<_> = candidates
-                .into_iter()
-                .enumerate()
-                .map(|(index, (_, candidate))| {
-                    StringMatchCandidate::new(index, candidate.label.as_ref())
-                })
-                .collect();
+            let candidates: Vec<_> = match &candidates {
+                Some(candidates) => candidates
+                    .into_iter()
+                    .enumerate()
+                    .map(|(index, (_, candidate))| {
+                        StringMatchCandidate::new(index, candidate.label.as_ref())
+                    })
+                    .collect(),
+                None => {
+                    let worktree_ids: Vec<_> = workspace
+                        .update(cx, |this, cx| {
+                            this.visible_worktrees(cx)
+                                .map(|tree| tree.read(cx).id())
+                                .collect()
+                        })
+                        .ok()
+                        .unwrap_or_default();
+
+                    let scenarios: Vec<_> = task_store
+                        .update(cx, |task_store, cx| {
+                            task_store.task_inventory().map(|item| {
+                                item.read(cx).list_debug_scenarios(worktree_ids.into_iter())
+                            })
+                        })
+                        .ok()
+                        .flatten()
+                        .unwrap_or_default();
+
+                    picker
+                        .update(cx, |picker, _| {
+                            picker.delegate.candidates = Some(scenarios.clone());
+                        })
+                        .ok();
+
+                    scenarios
+                        .into_iter()
+                        .enumerate()
+                        .map(|(index, (_, candidate))| {
+                            StringMatchCandidate::new(index, candidate.label.as_ref())
+                        })
+                        .collect()
+                }
+            };
 
             let matches = fuzzy::match_strings(
                 &candidates,
@@ -1061,13 +839,6 @@ impl PickerDelegate for DebugScenarioDelegate {
                     delegate.matches = matches;
                     delegate.prompt = query;
 
-                    delegate.divider_index = delegate.last_used_candidate_index.and_then(|index| {
-                        let index = delegate
-                            .matches
-                            .partition_point(|matching_task| matching_task.candidate_id <= index);
-                        Some(index).and_then(|index| (index != 0).then(|| index - 1))
-                    });
-
                     if delegate.matches.is_empty() {
                         delegate.selected_index = 0;
                     } else {
@@ -1079,47 +850,34 @@ impl PickerDelegate for DebugScenarioDelegate {
         })
     }
 
-    fn separators_after_indices(&self) -> Vec<usize> {
-        if let Some(i) = self.divider_index {
-            vec![i]
-        } else {
-            Vec::new()
-        }
-    }
-
     fn confirm(&mut self, _: bool, window: &mut Window, cx: &mut Context<picker::Picker<Self>>) {
         let debug_scenario = self
             .matches
             .get(self.selected_index())
-            .and_then(|match_candidate| self.candidates.get(match_candidate.candidate_id).cloned());
+            .and_then(|match_candidate| {
+                self.candidates
+                    .as_ref()
+                    .map(|candidates| candidates[match_candidate.candidate_id].clone())
+            });
 
-        let Some((_, mut debug_scenario)) = debug_scenario else {
+        let Some((task_source_kind, debug_scenario)) = debug_scenario else {
             return;
         };
 
-        let (task_context, worktree_id) = self
-            .task_contexts
-            .as_ref()
-            .and_then(|task_contexts| {
-                Some((
-                    task_contexts.active_context().cloned()?,
-                    task_contexts.worktree(),
-                ))
-            })
-            .unwrap_or_default();
-
-        if let Some(launch_config) =
-            debug_scenario
-                .request
-                .as_mut()
-                .and_then(|request| match request {
-                    DebugRequest::Launch(launch) => Some(launch),
-                    _ => None,
-                })
+        let (task_context, worktree_id) = if let TaskSourceKind::Worktree {
+            id: worktree_id,
+            directory_in_worktree: _,
+            id_base: _,
+        } = task_source_kind
         {
-            let (program, _) = resolve_paths(launch_config.program.clone(), String::new());
-            launch_config.program = program;
+            self.task_contexts
+                .task_context_for_worktree_id(worktree_id)
+                .cloned()
+                .map(|context| (context, Some(worktree_id)))
+        } else {
+            None
         }
+        .unwrap_or_default();
 
         self.debug_panel
             .update(cx, |panel, cx| {
@@ -1149,19 +907,10 @@ impl PickerDelegate for DebugScenarioDelegate {
             char_count: hit.string.chars().count(),
             color: Color::Default,
         };
-        let task_kind = &self.candidates[hit.candidate_id].0;
 
-        let icon = match task_kind {
-            Some(TaskSourceKind::Lsp(..)) => Some(Icon::new(IconName::Bolt)),
-            Some(TaskSourceKind::UserInput) => Some(Icon::new(IconName::Terminal)),
-            Some(TaskSourceKind::AbsPath { .. }) => Some(Icon::new(IconName::Settings)),
-            Some(TaskSourceKind::Worktree { .. }) => Some(Icon::new(IconName::FileTree)),
-            Some(TaskSourceKind::Language { name }) => file_icons::FileIcons::get(cx)
-                .get_icon_for_type(&name.to_lowercase(), cx)
-                .map(Icon::from_path),
-            None => Some(Icon::new(IconName::HistoryRerun)),
-        }
-        .map(|icon| icon.color(Color::Muted).size(ui::IconSize::Small));
+        let icon = Icon::new(IconName::FileTree)
+            .color(Color::Muted)
+            .size(ui::IconSize::Small);
 
         Some(
             ListItem::new(SharedString::from(format!("debug-scenario-selection-{ix}")))
@@ -1173,35 +922,3 @@ impl PickerDelegate for DebugScenarioDelegate {
         )
     }
 }
-
-fn resolve_paths(program: String, path: String) -> (String, String) {
-    let program = if let Some(program) = program.strip_prefix('~') {
-        format!(
-            "$ZED_WORKTREE_ROOT{}{}",
-            std::path::MAIN_SEPARATOR,
-            &program
-        )
-    } else if !program.starts_with(std::path::MAIN_SEPARATOR) {
-        format!(
-            "$ZED_WORKTREE_ROOT{}{}",
-            std::path::MAIN_SEPARATOR,
-            &program
-        )
-    } else {
-        program
-    };
-
-    let path = if path.starts_with('~') && !path.is_empty() {
-        format!(
-            "$ZED_WORKTREE_ROOT{}{}",
-            std::path::MAIN_SEPARATOR,
-            &path[1..]
-        )
-    } else if !path.starts_with(std::path::MAIN_SEPARATOR) && !path.is_empty() {
-        format!("$ZED_WORKTREE_ROOT{}{}", std::path::MAIN_SEPARATOR, &path)
-    } else {
-        path
-    };
-
-    (program, path)
-}

crates/debugger_ui/src/persistence.rs

@@ -278,7 +278,7 @@ pub(crate) fn deserialize_pane_layout(
                         cx,
                     )),
                     DebuggerPaneItem::Console => Box::new(SubView::new(
-                        console.focus_handle(cx),
+                        pane.focus_handle(cx),
                         console.clone().into(),
                         DebuggerPaneItem::Console,
                         Some(Box::new({
@@ -292,7 +292,7 @@ pub(crate) fn deserialize_pane_layout(
                         cx,
                     )),
                     DebuggerPaneItem::Terminal => Box::new(SubView::new(
-                        terminal.focus_handle(cx),
+                        pane.focus_handle(cx),
                         terminal.clone().into(),
                         DebuggerPaneItem::Terminal,
                         None,

crates/debugger_ui/src/session.rs

@@ -1,6 +1,7 @@
 pub mod running;
 
-use crate::{StackTraceView, debugger_panel::DebugPanel, persistence::SerializedLayout};
+use std::sync::OnceLock;
+
 use dap::client::SessionId;
 use gpui::{
     App, Axis, Entity, EventEmitter, FocusHandle, Focusable, Subscription, Task, WeakEntity,
@@ -10,21 +11,21 @@ use project::debugger::session::Session;
 use project::worktree_store::WorktreeStore;
 use rpc::proto;
 use running::RunningState;
-use std::{cell::OnceCell, sync::OnceLock};
 use ui::{Indicator, prelude::*};
 use workspace::{
     CollaboratorId, FollowableItem, ViewId, Workspace,
     item::{self, Item},
 };
 
+use crate::{debugger_panel::DebugPanel, persistence::SerializedLayout};
+
 pub struct DebugSession {
     remote_id: Option<workspace::ViewId>,
     running_state: Entity<RunningState>,
     label: OnceLock<SharedString>,
-    stack_trace_view: OnceCell<Entity<StackTraceView>>,
     _debug_panel: WeakEntity<DebugPanel>,
     _worktree_store: WeakEntity<WorktreeStore>,
-    workspace: WeakEntity<Workspace>,
+    _workspace: WeakEntity<Workspace>,
     _subscriptions: [Subscription; 1],
 }
 
@@ -65,9 +66,8 @@ impl DebugSession {
             running_state,
             label: OnceLock::new(),
             _debug_panel,
-            stack_trace_view: OnceCell::new(),
             _worktree_store: project.read(cx).worktree_store().downgrade(),
-            workspace,
+            _workspace: workspace,
         })
     }
 
@@ -75,32 +75,6 @@ impl DebugSession {
         self.running_state.read(cx).session_id()
     }
 
-    pub(crate) fn stack_trace_view(
-        &mut self,
-        project: &Entity<Project>,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) -> &Entity<StackTraceView> {
-        let workspace = self.workspace.clone();
-        let running_state = self.running_state.clone();
-
-        self.stack_trace_view.get_or_init(|| {
-            let stackframe_list = running_state.read(cx).stack_frame_list().clone();
-
-            let stack_frame_view = cx.new(|cx| {
-                StackTraceView::new(
-                    workspace.clone(),
-                    project.clone(),
-                    stackframe_list,
-                    window,
-                    cx,
-                )
-            });
-
-            stack_frame_view
-        })
-    }
-
     pub fn session(&self, cx: &App) -> Entity<Session> {
         self.running_state.read(cx).session().clone()
     }
@@ -157,11 +131,7 @@ impl DebugSession {
             .gap_2()
             .when_some(icon, |this, indicator| this.child(indicator))
             .justify_between()
-            .child(
-                Label::new(label)
-                    .size(LabelSize::Small)
-                    .when(is_terminated, |this| this.strikethrough()),
-            )
+            .child(Label::new(label).when(is_terminated, |this| this.strikethrough()))
             .into_any_element()
     }
 }

crates/debugger_ui/src/session/running.rs

@@ -43,10 +43,11 @@ use task::{
 };
 use terminal_view::TerminalView;
 use ui::{
-    ActiveTheme, AnyElement, App, ButtonCommon as _, Clickable as _, Context, FluentBuilder,
-    IconButton, IconName, IconSize, InteractiveElement, IntoElement, Label, LabelCommon as _,
-    ParentElement, Render, SharedString, StatefulInteractiveElement, Styled, Tab, Tooltip,
-    VisibleOnHover, VisualContext, Window, div, h_flex, v_flex,
+    ActiveTheme, AnyElement, App, ButtonCommon as _, Clickable as _, Context, ContextMenu,
+    Disableable, DropdownMenu, FluentBuilder, IconButton, IconName, IconSize, InteractiveElement,
+    IntoElement, Label, LabelCommon as _, ParentElement, Render, SharedString,
+    StatefulInteractiveElement, Styled, Tab, Tooltip, VisibleOnHover, VisualContext, Window, div,
+    h_flex, v_flex,
 };
 use util::ResultExt;
 use variable_list::VariableList;
@@ -77,12 +78,6 @@ pub struct RunningState {
     _schedule_serialize: Option<Task<()>>,
 }
 
-impl RunningState {
-    pub(crate) fn thread_id(&self) -> Option<ThreadId> {
-        self.thread_id
-    }
-}
-
 impl Render for RunningState {
     fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
         let zoomed_pane = self
@@ -124,7 +119,7 @@ impl Render for RunningState {
 
 pub(crate) struct SubView {
     inner: AnyView,
-    item_focus_handle: FocusHandle,
+    pane_focus_handle: FocusHandle,
     kind: DebuggerPaneItem,
     show_indicator: Box<dyn Fn(&App) -> bool>,
     hovered: bool,
@@ -132,7 +127,7 @@ pub(crate) struct SubView {
 
 impl SubView {
     pub(crate) fn new(
-        item_focus_handle: FocusHandle,
+        pane_focus_handle: FocusHandle,
         view: AnyView,
         kind: DebuggerPaneItem,
         show_indicator: Option<Box<dyn Fn(&App) -> bool>>,
@@ -141,7 +136,7 @@ impl SubView {
         cx.new(|_| Self {
             kind,
             inner: view,
-            item_focus_handle,
+            pane_focus_handle,
             show_indicator: show_indicator.unwrap_or(Box::new(|_| false)),
             hovered: false,
         })
@@ -153,7 +148,7 @@ impl SubView {
 }
 impl Focusable for SubView {
     fn focus_handle(&self, _: &App) -> FocusHandle {
-        self.item_focus_handle.clone()
+        self.pane_focus_handle.clone()
     }
 }
 impl EventEmitter<()> for SubView {}
@@ -204,7 +199,7 @@ impl Render for SubView {
             .size_full()
             // Add border unconditionally to prevent layout shifts on focus changes.
             .border_1()
-            .when(self.item_focus_handle.contains_focused(window, cx), |el| {
+            .when(self.pane_focus_handle.contains_focused(window, cx), |el| {
                 el.border_color(cx.theme().colors().pane_focused_border)
             })
             .child(self.inner.clone())
@@ -520,7 +515,7 @@ impl Focusable for DebugTerminal {
 }
 
 impl RunningState {
-    pub(crate) fn new(
+    pub fn new(
         session: Entity<Session>,
         project: Entity<Project>,
         workspace: WeakEntity<Workspace>,
@@ -1207,9 +1202,7 @@ impl RunningState {
             .as_ref()
             .and_then(|pane| self.panes.find_pane_in_direction(pane, direction, cx))
         {
-            pane.update(cx, |pane, cx| {
-                pane.focus_active_item(window, cx);
-            })
+            window.focus(&pane.focus_handle(cx));
         } else {
             self.workspace
                 .update(cx, |workspace, cx| {
@@ -1242,7 +1235,8 @@ impl RunningState {
         self.stack_frame_list.read(cx).selected_stack_frame_id()
     }
 
-    pub(crate) fn stack_frame_list(&self) -> &Entity<StackFrameList> {
+    #[cfg(test)]
+    pub fn stack_frame_list(&self) -> &Entity<StackFrameList> {
         &self.stack_frame_list
     }
 
@@ -1316,12 +1310,7 @@ impl RunningState {
             .map(|id| self.session().read(cx).thread_status(id))
     }
 
-    pub(crate) fn select_thread(
-        &mut self,
-        thread_id: ThreadId,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) {
+    fn select_thread(&mut self, thread_id: ThreadId, window: &mut Window, cx: &mut Context<Self>) {
         if self.thread_id.is_some_and(|id| id == thread_id) {
             return;
         }
@@ -1458,6 +1447,38 @@ impl RunningState {
         });
     }
 
+    pub(crate) fn thread_dropdown(
+        &self,
+        window: &mut Window,
+        cx: &mut Context<'_, RunningState>,
+    ) -> DropdownMenu {
+        let state = cx.entity();
+        let session_terminated = self.session.read(cx).is_terminated();
+        let threads = self.session.update(cx, |this, cx| this.threads(cx));
+        let selected_thread_name = threads
+            .iter()
+            .find(|(thread, _)| self.thread_id.map(|id| id.0) == Some(thread.id))
+            .map(|(thread, _)| thread.name.clone())
+            .unwrap_or("Threads".to_owned());
+        DropdownMenu::new(
+            ("thread-list", self.session_id.0),
+            selected_thread_name,
+            ContextMenu::build_eager(window, cx, move |mut this, _, _| {
+                for (thread, _) in threads {
+                    let state = state.clone();
+                    let thread_id = thread.id;
+                    this = this.entry(thread.name, None, move |window, cx| {
+                        state.update(cx, |state, cx| {
+                            state.select_thread(ThreadId(thread_id), window, cx);
+                        });
+                    });
+                }
+                this
+            }),
+        )
+        .disabled(session_terminated)
+    }
+
     fn default_pane_layout(
         project: Entity<Project>,
         workspace: &WeakEntity<Workspace>,

crates/debugger_ui/src/session/running/console.rs

@@ -5,7 +5,7 @@ use super::{
 use anyhow::Result;
 use collections::HashMap;
 use dap::OutputEvent;
-use editor::{Bias, CompletionProvider, Editor, EditorElement, EditorStyle, ExcerptId};
+use editor::{CompletionProvider, Editor, EditorElement, EditorStyle, ExcerptId};
 use fuzzy::StringMatchCandidate;
 use gpui::{
     Context, Entity, FocusHandle, Focusable, Render, Subscription, Task, TextStyle, WeakEntity,
@@ -45,7 +45,6 @@ impl Console {
             let mut editor = Editor::multi_line(window, cx);
             editor.move_to_end(&editor::actions::MoveToEnd, window, cx);
             editor.set_read_only(true);
-            editor.disable_scrollbars_and_minimap(window, cx);
             editor.set_show_gutter(false, cx);
             editor.set_show_runnables(false, cx);
             editor.set_show_breakpoints(false, cx);
@@ -77,14 +76,8 @@ impl Console {
             editor
         });
 
-        let _subscriptions = vec![
-            cx.subscribe(&stack_frame_list, Self::handle_stack_frame_list_events),
-            cx.on_focus_in(&focus_handle, window, |console, window, cx| {
-                if console.is_running(cx) {
-                    console.query_bar.focus_handle(cx).focus(window);
-                }
-            }),
-        ];
+        let _subscriptions =
+            vec![cx.subscribe(&stack_frame_list, Self::handle_stack_frame_list_events)];
 
         Self {
             session,
@@ -104,7 +97,7 @@ impl Console {
         &self.console
     }
 
-    fn is_running(&self, cx: &Context<Self>) -> bool {
+    fn is_local(&self, cx: &Context<Self>) -> bool {
         self.session.read(cx).is_local()
     }
 
@@ -116,7 +109,6 @@ impl Console {
     ) {
         match event {
             StackFrameListEvent::SelectedStackFrameChanged(_) => cx.notify(),
-            StackFrameListEvent::BuiltEntries => {}
         }
     }
 
@@ -150,9 +142,8 @@ impl Console {
     pub fn evaluate(&mut self, _: &Confirm, window: &mut Window, cx: &mut Context<Self>) {
         let expression = self.query_bar.update(cx, |editor, cx| {
             let expression = editor.text(cx);
-            cx.defer_in(window, |editor, window, cx| {
-                editor.clear(window, cx);
-            });
+
+            editor.clear(window, cx);
 
             expression
         });
@@ -227,7 +218,7 @@ impl Render for Console {
             .on_action(cx.listener(Self::evaluate))
             .size_full()
             .child(self.render_console(cx))
-            .when(self.is_running(cx), |this| {
+            .when(self.is_local(cx), |this| {
                 this.child(Divider::horizontal())
                     .child(self.render_query_bar(cx))
             })
@@ -410,21 +401,28 @@ impl ConsoleQueryBarCompletionProvider {
                             .as_ref()
                             .unwrap_or(&completion.label)
                             .to_owned();
-                        let buffer_text = snapshot.text();
-                        let buffer_bytes = buffer_text.as_bytes();
-                        let new_bytes = new_text.as_bytes();
+                        let mut word_bytes_length = 0;
+                        for chunk in snapshot
+                            .reversed_chunks_in_range(language::Anchor::MIN..buffer_position)
+                        {
+                            let mut processed_bytes = 0;
+                            if let Some(_) = chunk.chars().rfind(|c| {
+                                let is_whitespace = c.is_whitespace();
+                                if !is_whitespace {
+                                    processed_bytes += c.len_utf8();
+                                }
 
-                        let mut prefix_len = 0;
-                        for i in (0..new_bytes.len()).rev() {
-                            if buffer_bytes.ends_with(&new_bytes[0..i]) {
-                                prefix_len = i;
+                                is_whitespace
+                            }) {
+                                word_bytes_length += processed_bytes;
                                 break;
+                            } else {
+                                word_bytes_length += chunk.len();
                             }
                         }
 
                         let buffer_offset = buffer_position.to_offset(&snapshot);
-                        let start = buffer_offset - prefix_len;
-                        let start = snapshot.clip_offset(start, Bias::Left);
+                        let start = buffer_offset - word_bytes_length;
                         let start = snapshot.anchor_before(start);
                         let replace_range = start..buffer_position;
 

crates/debugger_ui/src/session/running/stack_frame_list.rs

@@ -15,16 +15,13 @@ use project::debugger::session::{Session, SessionEvent, StackFrame};
 use project::{ProjectItem, ProjectPath};
 use ui::{Scrollbar, ScrollbarState, Tooltip, prelude::*};
 use util::ResultExt;
-use workspace::{ItemHandle, Workspace};
-
-use crate::StackTraceView;
+use workspace::Workspace;
 
 use super::RunningState;
 
 #[derive(Debug)]
 pub enum StackFrameListEvent {
     SelectedStackFrameChanged(StackFrameId),
-    BuiltEntries,
 }
 
 pub struct StackFrameList {
@@ -104,18 +101,13 @@ impl StackFrameList {
         &self.entries
     }
 
-    pub(crate) fn flatten_entries(&self, show_collapsed: bool) -> Vec<dap::StackFrame> {
+    #[cfg(test)]
+    pub(crate) fn flatten_entries(&self) -> Vec<dap::StackFrame> {
         self.entries
             .iter()
             .flat_map(|frame| match frame {
                 StackFrameEntry::Normal(frame) => vec![frame.clone()],
-                StackFrameEntry::Collapsed(frames) => {
-                    if show_collapsed {
-                        frames.clone()
-                    } else {
-                        vec![]
-                    }
-                }
+                StackFrameEntry::Collapsed(frames) => frames.clone(),
             })
             .collect::<Vec<_>>()
     }
@@ -144,25 +136,6 @@ impl StackFrameList {
         self.selected_stack_frame_id
     }
 
-    pub(crate) fn select_stack_frame_id(
-        &mut self,
-        id: StackFrameId,
-        window: &Window,
-        cx: &mut Context<Self>,
-    ) {
-        if !self.entries.iter().any(|entry| match entry {
-            StackFrameEntry::Normal(entry) => entry.id == id,
-            StackFrameEntry::Collapsed(stack_frames) => {
-                stack_frames.iter().any(|frame| frame.id == id)
-            }
-        }) {
-            return;
-        }
-
-        self.selected_stack_frame_id = Some(id);
-        self.go_to_selected_stack_frame(window, cx);
-    }
-
     pub(super) fn schedule_refresh(
         &mut self,
         select_first: bool,
@@ -233,7 +206,6 @@ impl StackFrameList {
                 .detach_and_log_err(cx);
         }
 
-        cx.emit(StackFrameListEvent::BuiltEntries);
         cx.notify();
     }
 
@@ -283,7 +255,7 @@ impl StackFrameList {
 
         let row = (stack_frame.line.saturating_sub(1)) as u32;
 
-        let Some(abs_path) = Self::abs_path_from_stack_frame(&stack_frame) else {
+        let Some(abs_path) = self.abs_path_from_stack_frame(&stack_frame) else {
             return Task::ready(Err(anyhow!("Project path not found")));
         };
 
@@ -322,22 +294,12 @@ impl StackFrameList {
                     let project_path = buffer.read(cx).project_path(cx).ok_or_else(|| {
                         anyhow!("Could not select a stack frame for unnamed buffer")
                     })?;
-
-                    let open_preview = !workspace
-                        .item_of_type::<StackTraceView>(cx)
-                        .map(|viewer| {
-                            workspace
-                                .active_item(cx)
-                                .is_some_and(|item| item.item_id() == viewer.item_id())
-                        })
-                        .unwrap_or_default();
-
                     anyhow::Ok(workspace.open_path_preview(
                         project_path,
                         None,
+                        false,
                         true,
                         true,
-                        open_preview,
                         window,
                         cx,
                     ))
@@ -370,7 +332,7 @@ impl StackFrameList {
         })
     }
 
-    pub(crate) fn abs_path_from_stack_frame(stack_frame: &dap::StackFrame) -> Option<Arc<Path>> {
+    fn abs_path_from_stack_frame(&self, stack_frame: &dap::StackFrame) -> Option<Arc<Path>> {
         stack_frame.source.as_ref().and_then(|s| {
             s.path
                 .as_deref()

crates/debugger_ui/src/session/running/variable_list.rs

@@ -302,7 +302,6 @@ impl VariableList {
                 self.selected_stack_frame_id = Some(*stack_frame_id);
                 cx.notify();
             }
-            StackFrameListEvent::BuiltEntries => {}
         }
     }
 

crates/debugger_ui/src/stack_trace_view.rs

@@ -1,453 +0,0 @@
-use std::any::{Any, TypeId};
-
-use collections::HashMap;
-use dap::StackFrameId;
-use editor::{
-    Anchor, Bias, DebugStackFrameLine, Editor, EditorEvent, ExcerptId, ExcerptRange, MultiBuffer,
-    RowHighlightOptions, ToPoint, scroll::Autoscroll,
-};
-use gpui::{
-    AnyView, App, AppContext, Entity, EventEmitter, Focusable, IntoElement, Render, SharedString,
-    Subscription, Task, WeakEntity, Window,
-};
-use language::{BufferSnapshot, Capability, Point, Selection, SelectionGoal, TreeSitterOptions};
-use project::{Project, ProjectPath};
-use ui::{ActiveTheme as _, Context, ParentElement as _, Styled as _, div};
-use util::ResultExt as _;
-use workspace::{
-    Item, ItemHandle as _, ItemNavHistory, ToolbarItemLocation, Workspace,
-    item::{BreadcrumbText, ItemEvent},
-    searchable::SearchableItemHandle,
-};
-
-use crate::session::running::stack_frame_list::{StackFrameList, StackFrameListEvent};
-use anyhow::Result;
-
-pub(crate) struct StackTraceView {
-    editor: Entity<Editor>,
-    multibuffer: Entity<MultiBuffer>,
-    workspace: WeakEntity<Workspace>,
-    project: Entity<Project>,
-    stack_frame_list: Entity<StackFrameList>,
-    selected_stack_frame_id: Option<StackFrameId>,
-    highlights: Vec<(StackFrameId, Anchor)>,
-    excerpt_for_frames: collections::HashMap<ExcerptId, StackFrameId>,
-    refresh_task: Option<Task<Result<()>>>,
-    _subscription: Option<Subscription>,
-}
-
-impl StackTraceView {
-    pub(crate) fn new(
-        workspace: WeakEntity<Workspace>,
-        project: Entity<Project>,
-        stack_frame_list: Entity<StackFrameList>,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) -> Self {
-        let multibuffer = cx.new(|_| MultiBuffer::new(Capability::ReadWrite));
-        let editor = cx.new(|cx| {
-            let mut editor =
-                Editor::for_multibuffer(multibuffer.clone(), Some(project.clone()), window, cx);
-            editor.set_vertical_scroll_margin(5, cx);
-            editor
-        });
-
-        cx.subscribe_in(&editor, window, |this, editor, event, window, cx| {
-            if let EditorEvent::SelectionsChanged { local: true } = event {
-                let excerpt_id = editor.update(cx, |editor, cx| {
-                    let position: Point = editor.selections.newest(cx).head();
-
-                    editor
-                        .snapshot(window, cx)
-                        .buffer_snapshot
-                        .excerpt_containing(position..position)
-                        .map(|excerpt| excerpt.id())
-                });
-
-                if let Some(stack_frame_id) = excerpt_id
-                    .and_then(|id| this.excerpt_for_frames.get(&id))
-                    .filter(|id| Some(**id) != this.selected_stack_frame_id)
-                {
-                    this.stack_frame_list.update(cx, |list, cx| {
-                        list.select_stack_frame_id(*stack_frame_id, window, cx);
-                    });
-                }
-            }
-        })
-        .detach();
-
-        cx.subscribe_in(
-            &stack_frame_list,
-            window,
-            |this, stack_frame_list, event, window, cx| match event {
-                StackFrameListEvent::BuiltEntries => {
-                    this.selected_stack_frame_id =
-                        stack_frame_list.read(cx).selected_stack_frame_id();
-                    this.update_excerpts(window, cx);
-                }
-                StackFrameListEvent::SelectedStackFrameChanged(selected_frame_id) => {
-                    this.selected_stack_frame_id = Some(*selected_frame_id);
-                    this.update_highlights(window, cx);
-
-                    if let Some(frame_anchor) = this
-                        .highlights
-                        .iter()
-                        .find(|(frame_id, _)| frame_id == selected_frame_id)
-                        .map(|highlight| highlight.1)
-                    {
-                        this.editor.update(cx, |editor, cx| {
-                            if frame_anchor.excerpt_id
-                                != editor.selections.newest_anchor().head().excerpt_id
-                            {
-                                let auto_scroll =
-                                    Some(Autoscroll::center().for_anchor(frame_anchor));
-
-                                editor.change_selections(auto_scroll, window, cx, |selections| {
-                                    let selection_id = selections.new_selection_id();
-
-                                    let selection = Selection {
-                                        id: selection_id,
-                                        start: frame_anchor,
-                                        end: frame_anchor,
-                                        goal: SelectionGoal::None,
-                                        reversed: false,
-                                    };
-
-                                    selections.select_anchors(vec![selection]);
-                                })
-                            }
-                        });
-                    }
-                }
-            },
-        )
-        .detach();
-
-        let mut this = Self {
-            editor,
-            multibuffer,
-            workspace,
-            project,
-            excerpt_for_frames: HashMap::default(),
-            highlights: Vec::default(),
-            stack_frame_list,
-            selected_stack_frame_id: None,
-            refresh_task: None,
-            _subscription: None,
-        };
-
-        this.update_excerpts(window, cx);
-        this
-    }
-
-    fn update_excerpts(&mut self, window: &mut Window, cx: &mut Context<Self>) {
-        self.refresh_task.take();
-        self.editor.update(cx, |editor, cx| {
-            editor.clear_highlights::<DebugStackFrameLine>(cx)
-        });
-
-        let stack_frames = self
-            .stack_frame_list
-            .update(cx, |list, _| list.flatten_entries(false));
-
-        let frames_to_open: Vec<_> = stack_frames
-            .into_iter()
-            .filter_map(|frame| {
-                Some((
-                    frame.id,
-                    frame.line as u32 - 1,
-                    StackFrameList::abs_path_from_stack_frame(&frame)?,
-                ))
-            })
-            .collect();
-
-        self.multibuffer
-            .update(cx, |multi_buffer, cx| multi_buffer.clear(cx));
-
-        let task = cx.spawn_in(window, async move |this, cx| {
-            let mut to_highlights = Vec::default();
-
-            for (stack_frame_id, line, abs_path) in frames_to_open {
-                let (worktree, relative_path) = this
-                    .update(cx, |this, cx| {
-                        this.workspace.update(cx, |workspace, cx| {
-                            workspace.project().update(cx, |this, cx| {
-                                this.find_or_create_worktree(&abs_path, false, cx)
-                            })
-                        })
-                    })??
-                    .await?;
-
-                let project_path = ProjectPath {
-                    worktree_id: worktree.read_with(cx, |tree, _| tree.id())?,
-                    path: relative_path.into(),
-                };
-
-                if let Some(buffer) = this
-                    .read_with(cx, |this, _| this.project.clone())?
-                    .update(cx, |project, cx| project.open_buffer(project_path, cx))?
-                    .await
-                    .log_err()
-                {
-                    this.update(cx, |this, cx| {
-                        this.multibuffer.update(cx, |multi_buffer, cx| {
-                            let line_point = Point::new(line, 0);
-                            let start_context = Self::heuristic_syntactic_expand(
-                                &buffer.read(cx).snapshot(),
-                                line_point,
-                            );
-
-                            // Users will want to see what happened before an active debug line in most cases
-                            let range = ExcerptRange {
-                                context: start_context..Point::new(line.saturating_add(1), 0),
-                                primary: line_point..line_point,
-                            };
-                            multi_buffer.push_excerpts(buffer.clone(), vec![range], cx);
-
-                            let line_anchor =
-                                multi_buffer.buffer_point_to_anchor(&buffer, line_point, cx);
-
-                            if let Some(line_anchor) = line_anchor {
-                                this.excerpt_for_frames
-                                    .insert(line_anchor.excerpt_id, stack_frame_id);
-                                to_highlights.push((stack_frame_id, line_anchor));
-                            }
-                        });
-                    })
-                    .ok();
-                }
-            }
-
-            this.update_in(cx, |this, window, cx| {
-                this.highlights = to_highlights;
-                this.update_highlights(window, cx);
-            })
-            .ok();
-
-            anyhow::Ok(())
-        });
-
-        self.refresh_task = Some(task);
-    }
-
-    fn update_highlights(&mut self, window: &mut Window, cx: &mut Context<Self>) {
-        self.editor.update(cx, |editor, _| {
-            editor.clear_row_highlights::<DebugStackFrameLine>()
-        });
-
-        let stack_frames = self
-            .stack_frame_list
-            .update(cx, |session, _| session.flatten_entries(false));
-
-        let active_idx = self
-            .selected_stack_frame_id
-            .and_then(|id| {
-                stack_frames
-                    .iter()
-                    .enumerate()
-                    .find_map(|(idx, frame)| if frame.id == id { Some(idx) } else { None })
-            })
-            .unwrap_or(0);
-
-        self.editor.update(cx, |editor, cx| {
-            let snapshot = editor.snapshot(window, cx).display_snapshot;
-            let first_color = cx.theme().colors().editor_debugger_active_line_background;
-
-            let color = first_color.opacity(0.5);
-
-            let mut is_first = true;
-
-            for (_, highlight) in self.highlights.iter().skip(active_idx) {
-                let position = highlight.to_point(&snapshot.buffer_snapshot);
-                let color = if is_first {
-                    is_first = false;
-                    first_color
-                } else {
-                    color
-                };
-
-                let start = snapshot
-                    .buffer_snapshot
-                    .clip_point(Point::new(position.row, 0), Bias::Left);
-                let end = start + Point::new(1, 0);
-                let start = snapshot.buffer_snapshot.anchor_before(start);
-                let end = snapshot.buffer_snapshot.anchor_before(end);
-                editor.highlight_rows::<DebugStackFrameLine>(
-                    start..end,
-                    color,
-                    RowHighlightOptions::default(),
-                    cx,
-                );
-            }
-        })
-    }
-
-    fn heuristic_syntactic_expand(snapshot: &BufferSnapshot, selected_point: Point) -> Point {
-        let mut text_objects = snapshot.text_object_ranges(
-            selected_point..selected_point,
-            TreeSitterOptions::max_start_depth(4),
-        );
-
-        let mut start_position = text_objects
-            .find(|(_, obj)| matches!(obj, language::TextObject::AroundFunction))
-            .map(|(range, _)| snapshot.offset_to_point(range.start))
-            .map(|point| Point::new(point.row.max(selected_point.row.saturating_sub(8)), 0))
-            .unwrap_or(selected_point);
-
-        if start_position.row == selected_point.row {
-            start_position.row = start_position.row.saturating_sub(1);
-        }
-
-        start_position
-    }
-}
-
-impl Render for StackTraceView {
-    fn render(&mut self, _: &mut Window, _: &mut Context<Self>) -> impl IntoElement {
-        div().size_full().child(self.editor.clone())
-    }
-}
-
-impl EventEmitter<EditorEvent> for StackTraceView {}
-impl Focusable for StackTraceView {
-    fn focus_handle(&self, cx: &App) -> gpui::FocusHandle {
-        self.editor.focus_handle(cx)
-    }
-}
-
-impl Item for StackTraceView {
-    type Event = EditorEvent;
-
-    fn to_item_events(event: &EditorEvent, f: impl FnMut(ItemEvent)) {
-        Editor::to_item_events(event, f)
-    }
-
-    fn deactivated(&mut self, window: &mut Window, cx: &mut Context<Self>) {
-        self.editor
-            .update(cx, |editor, cx| editor.deactivated(window, cx));
-    }
-
-    fn navigate(
-        &mut self,
-        data: Box<dyn Any>,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) -> bool {
-        self.editor
-            .update(cx, |editor, cx| editor.navigate(data, window, cx))
-    }
-
-    fn tab_tooltip_text(&self, _: &App) -> Option<SharedString> {
-        Some("Stack Frame Viewer".into())
-    }
-
-    fn tab_content_text(&self, _detail: usize, _: &App) -> SharedString {
-        "Stack Frames".into()
-    }
-
-    fn for_each_project_item(
-        &self,
-        cx: &App,
-        f: &mut dyn FnMut(gpui::EntityId, &dyn project::ProjectItem),
-    ) {
-        self.editor.for_each_project_item(cx, f)
-    }
-
-    fn is_singleton(&self, _: &App) -> bool {
-        false
-    }
-
-    fn set_nav_history(
-        &mut self,
-        nav_history: ItemNavHistory,
-        _: &mut Window,
-        cx: &mut Context<Self>,
-    ) {
-        self.editor.update(cx, |editor, _| {
-            editor.set_nav_history(Some(nav_history));
-        });
-    }
-
-    fn is_dirty(&self, cx: &App) -> bool {
-        self.multibuffer.read(cx).is_dirty(cx)
-    }
-
-    fn has_deleted_file(&self, cx: &App) -> bool {
-        self.multibuffer.read(cx).has_deleted_file(cx)
-    }
-
-    fn has_conflict(&self, cx: &App) -> bool {
-        self.multibuffer.read(cx).has_conflict(cx)
-    }
-
-    fn can_save(&self, _: &App) -> bool {
-        true
-    }
-
-    fn save(
-        &mut self,
-        format: bool,
-        project: Entity<Project>,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) -> Task<Result<()>> {
-        self.editor.save(format, project, window, cx)
-    }
-
-    fn save_as(
-        &mut self,
-        _: Entity<Project>,
-        _: ProjectPath,
-        _window: &mut Window,
-        _: &mut Context<Self>,
-    ) -> Task<Result<()>> {
-        unreachable!()
-    }
-
-    fn reload(
-        &mut self,
-        project: Entity<Project>,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) -> Task<Result<()>> {
-        self.editor.reload(project, window, cx)
-    }
-
-    fn act_as_type<'a>(
-        &'a self,
-        type_id: TypeId,
-        self_handle: &'a Entity<Self>,
-        _: &'a App,
-    ) -> Option<AnyView> {
-        if type_id == TypeId::of::<Self>() {
-            Some(self_handle.to_any())
-        } else if type_id == TypeId::of::<Editor>() {
-            Some(self.editor.to_any())
-        } else {
-            None
-        }
-    }
-
-    fn as_searchable(&self, _: &Entity<Self>) -> Option<Box<dyn SearchableItemHandle>> {
-        Some(Box::new(self.editor.clone()))
-    }
-
-    fn breadcrumb_location(&self, _: &App) -> ToolbarItemLocation {
-        ToolbarItemLocation::PrimaryLeft
-    }
-
-    fn breadcrumbs(&self, theme: &theme::Theme, cx: &App) -> Option<Vec<BreadcrumbText>> {
-        self.editor.breadcrumbs(theme, cx)
-    }
-
-    fn added_to_workspace(
-        &mut self,
-        workspace: &mut Workspace,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) {
-        self.editor.update(cx, |editor, cx| {
-            editor.added_to_workspace(workspace, window, cx)
-        });
-    }
-}

crates/debugger_ui/src/tests/inline_values.rs

@@ -1,7 +1,7 @@
 use std::{path::Path, sync::Arc};
 
 use dap::{Scope, StackFrame, Variable, requests::Variables};
-use editor::{Editor, EditorMode, MultiBuffer};
+use editor::{Editor, EditorMode, MultiBuffer, actions::ToggleInlineValues};
 use gpui::{BackgroundExecutor, TestAppContext, VisualTestContext};
 use language::{Language, LanguageConfig, LanguageMatcher, tree_sitter_python, tree_sitter_rust};
 use project::{FakeFs, Project};
@@ -239,7 +239,11 @@ fn main() {
     });
     cx.run_until_parked();
 
-    editor.update(cx, |editor, cx| editor.refresh_inline_values(cx));
+    editor.update_in(cx, |editor, window, cx| {
+        if !editor.inline_values_enabled() {
+            editor.toggle_inline_values(&ToggleInlineValues, window, cx);
+        }
+    });
 
     cx.run_until_parked();
 
@@ -1600,7 +1604,11 @@ def process_data(untyped_param, typed_param: int, another_typed: str):
         )
     });
 
-    editor.update(cx, |editor, cx| editor.refresh_inline_values(cx));
+    editor.update_in(cx, |editor, window, cx| {
+        if !editor.inline_values_enabled() {
+            editor.toggle_inline_values(&ToggleInlineValues, window, cx);
+        }
+    });
 
     client.on_request::<dap::requests::Threads, _>(move |_, _| {
         Ok(dap::ThreadsResponse {

crates/debugger_ui/src/tests/variable_list.rs

@@ -190,7 +190,7 @@ async fn test_basic_fetch_initial_scope_and_variables(
     running_state.update(cx, |running_state, cx| {
         let (stack_frame_list, stack_frame_id) =
             running_state.stack_frame_list().update(cx, |list, _| {
-                (list.flatten_entries(true), list.selected_stack_frame_id())
+                (list.flatten_entries(), list.selected_stack_frame_id())
             });
 
         assert_eq!(stack_frames, stack_frame_list);
@@ -431,7 +431,7 @@ async fn test_fetch_variables_for_multiple_scopes(
     running_state.update(cx, |running_state, cx| {
         let (stack_frame_list, stack_frame_id) =
             running_state.stack_frame_list().update(cx, |list, _| {
-                (list.flatten_entries(true), list.selected_stack_frame_id())
+                (list.flatten_entries(), list.selected_stack_frame_id())
             });
 
         assert_eq!(Some(1), stack_frame_id);
@@ -1452,7 +1452,7 @@ async fn test_variable_list_only_sends_requests_when_rendering(
     running_state.update(cx, |running_state, cx| {
         let (stack_frame_list, stack_frame_id) =
             running_state.stack_frame_list().update(cx, |list, _| {
-                (list.flatten_entries(true), list.selected_stack_frame_id())
+                (list.flatten_entries(), list.selected_stack_frame_id())
             });
 
         assert_eq!(Some(1), stack_frame_id);
@@ -1734,7 +1734,7 @@ async fn test_it_fetches_scopes_variables_when_you_select_a_stack_frame(
     running_state.update(cx, |running_state, cx| {
         let (stack_frame_list, stack_frame_id) =
             running_state.stack_frame_list().update(cx, |list, _| {
-                (list.flatten_entries(true), list.selected_stack_frame_id())
+                (list.flatten_entries(), list.selected_stack_frame_id())
             });
 
         let variable_list = running_state.variable_list().read(cx);
@@ -1789,7 +1789,7 @@ async fn test_it_fetches_scopes_variables_when_you_select_a_stack_frame(
     running_state.update(cx, |running_state, cx| {
         let (stack_frame_list, stack_frame_id) =
             running_state.stack_frame_list().update(cx, |list, _| {
-                (list.flatten_entries(true), list.selected_stack_frame_id())
+                (list.flatten_entries(), list.selected_stack_frame_id())
             });
 
         let variable_list = running_state.variable_list().read(cx);

crates/diagnostics/src/items.rs

@@ -6,8 +6,6 @@ use gpui::{
     WeakEntity, Window,
 };
 use language::Diagnostic;
-use project::project_settings::ProjectSettings;
-use settings::Settings;
 use ui::{Button, ButtonLike, Color, Icon, IconName, Label, Tooltip, h_flex, prelude::*};
 use workspace::{StatusItemView, ToolbarItemEvent, Workspace, item::ItemHandle};
 
@@ -24,11 +22,6 @@ pub struct DiagnosticIndicator {
 
 impl Render for DiagnosticIndicator {
     fn render(&mut self, _: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
-        let indicator = h_flex().gap_2();
-        if !ProjectSettings::get_global(cx).diagnostics.button {
-            return indicator;
-        }
-
         let diagnostic_indicator = match (self.summary.error_count, self.summary.warning_count) {
             (0, 0) => h_flex().map(|this| {
                 this.child(
@@ -91,7 +84,8 @@ impl Render for DiagnosticIndicator {
             None
         };
 
-        indicator
+        h_flex()
+            .gap_2()
             .child(
                 ButtonLike::new("diagnostic-indicator")
                     .child(diagnostic_indicator)

crates/editor/src/code_context_menus.rs

@@ -450,7 +450,29 @@ impl CompletionsMenu {
         window: &mut Window,
         cx: &mut Context<Editor>,
     ) -> AnyElement {
+        let completions = self.completions.borrow_mut();
         let show_completion_documentation = self.show_completion_documentation;
+        let widest_completion_ix = self
+            .entries
+            .borrow()
+            .iter()
+            .enumerate()
+            .max_by_key(|(_, mat)| {
+                let completion = &completions[mat.candidate_id];
+                let documentation = &completion.documentation;
+
+                let mut len = completion.label.text.chars().count();
+                if let Some(CompletionDocumentation::SingleLine(text)) = documentation {
+                    if show_completion_documentation {
+                        len += text.chars().count();
+                    }
+                }
+
+                len
+            })
+            .map(|(ix, _)| ix);
+        drop(completions);
+
         let selected_item = self.selected_item;
         let completions = self.completions.clone();
         let entries = self.entries.clone();
@@ -510,25 +532,22 @@ impl CompletionsMenu {
 
                         let completion_label = StyledText::new(completion.label.text.clone())
                             .with_default_highlights(&style.text, highlights);
-
-                        let documentation_label = match documentation {
-                            Some(CompletionDocumentation::SingleLine(text))
-                            | Some(CompletionDocumentation::SingleLineAndMultiLinePlainText {
-                                single_line: text,
-                                ..
-                            }) => {
-                                if text.trim().is_empty() {
-                                    None
-                                } else {
-                                    Some(
-                                        Label::new(text.clone())
-                                            .ml_4()
-                                            .size(LabelSize::Small)
-                                            .color(Color::Muted),
-                                    )
-                                }
+                        let documentation_label = if let Some(
+                            CompletionDocumentation::SingleLine(text),
+                        ) = documentation
+                        {
+                            if text.trim().is_empty() {
+                                None
+                            } else {
+                                Some(
+                                    Label::new(text.clone())
+                                        .ml_4()
+                                        .size(LabelSize::Small)
+                                        .color(Color::Muted),
+                                )
                             }
-                            _ => None,
+                        } else {
+                            None
                         };
 
                         let start_slot = completion
@@ -577,8 +596,8 @@ impl CompletionsMenu {
         .occlude()
         .max_h(max_height_in_lines as f32 * window.line_height())
         .track_scroll(self.scroll_handle.clone())
-        .with_sizing_behavior(ListSizingBehavior::Infer)
-        .w(rems(34.));
+        .with_width_from_item(widest_completion_ix)
+        .with_sizing_behavior(ListSizingBehavior::Infer);
 
         Popover::new().child(list).into_any_element()
     }
@@ -600,10 +619,6 @@ impl CompletionsMenu {
             .as_ref()?
         {
             CompletionDocumentation::MultiLinePlainText(text) => div().child(text.clone()),
-            CompletionDocumentation::SingleLineAndMultiLinePlainText {
-                plain_text: Some(text),
-                ..
-            } => div().child(text.clone()),
             CompletionDocumentation::MultiLineMarkdown(parsed) if !parsed.is_empty() => {
                 let markdown = self.markdown_element.get_or_insert_with(|| {
                     cx.new(|cx| {
@@ -634,11 +649,6 @@ impl CompletionsMenu {
             CompletionDocumentation::MultiLineMarkdown(_) => return None,
             CompletionDocumentation::SingleLine(_) => return None,
             CompletionDocumentation::Undocumented => return None,
-            CompletionDocumentation::SingleLineAndMultiLinePlainText {
-                plain_text: None, ..
-            } => {
-                return None;
-            }
         };
 
         Some(
@@ -1103,7 +1113,6 @@ impl CodeActionsMenu {
                                     this.child(
                                         h_flex()
                                             .overflow_hidden()
-                                            .child("debug: ")
                                             .child(scenario.label.clone())
                                             .when(selected, |this| {
                                                 this.text_color(colors.text_accent)
@@ -1139,9 +1148,7 @@ impl CodeActionsMenu {
                     CodeActionsItem::CodeAction { action, .. } => {
                         action.lsp_action.title().chars().count()
                     }
-                    CodeActionsItem::DebugScenario(scenario) => {
-                        format!("debug: {}", scenario.label).chars().count()
-                    }
+                    CodeActionsItem::DebugScenario(scenario) => scenario.label.chars().count(),
                 })
                 .map(|(ix, _)| ix),
         )

crates/editor/src/editor.rs

@@ -289,7 +289,6 @@ impl InlayId {
 }
 
 pub enum ActiveDebugLine {}
-pub enum DebugStackFrameLine {}
 enum DocumentHighlightRead {}
 enum DocumentHighlightWrite {}
 enum InputComposition {}
@@ -5332,9 +5331,9 @@ impl Editor {
                                                     .map(SharedString::from)
                                             })?;
 
-                                    dap_store.update(cx, |dap_store, cx| {
+                                    dap_store.update(cx, |this, cx| {
                                         for (_, task) in &resolved_tasks.templates {
-                                            if let Some(scenario) = dap_store
+                                            if let Some(scenario) = this
                                                 .debug_scenario_for_build_task(
                                                     task.original_task().clone(),
                                                     debug_adapter.clone().into(),
@@ -5759,22 +5758,10 @@ impl Editor {
         let cursor_position = newest_selection.head();
         let (cursor_buffer, cursor_buffer_position) =
             buffer.text_anchor_for_position(cursor_position, cx)?;
-        let (tail_buffer, tail_buffer_position) =
-            buffer.text_anchor_for_position(newest_selection.tail(), cx)?;
+        let (tail_buffer, _) = buffer.text_anchor_for_position(newest_selection.tail(), cx)?;
         if cursor_buffer != tail_buffer {
             return None;
         }
-
-        let snapshot = cursor_buffer.read(cx).snapshot();
-        let (start_word_range, _) = snapshot.surrounding_word(cursor_buffer_position);
-        let (end_word_range, _) = snapshot.surrounding_word(tail_buffer_position);
-        if start_word_range != end_word_range {
-            self.document_highlights_task.take();
-            self.clear_background_highlights::<DocumentHighlightRead>(cx);
-            self.clear_background_highlights::<DocumentHighlightWrite>(cx);
-            return None;
-        }
-
         let debounce = EditorSettings::get_global(cx).lsp_highlight_debounce;
         self.document_highlights_task = Some(cx.spawn(async move |this, cx| {
             cx.background_executor()
@@ -13881,10 +13868,7 @@ impl Editor {
             Default::default(),
             cx,
         );
-
-        if self.buffer.read(cx).is_singleton() {
-            self.request_autoscroll(Autoscroll::center().for_anchor(start), cx);
-        }
+        self.request_autoscroll(Autoscroll::center().for_anchor(start), cx);
     }
 
     pub fn go_to_definition(
@@ -16890,7 +16874,6 @@ impl Editor {
 
                 handled = true;
                 self.clear_row_highlights::<ActiveDebugLine>();
-
                 self.go_to_line::<ActiveDebugLine>(
                     multibuffer_anchor,
                     Some(cx.theme().colors().editor_debugger_active_line_background),
@@ -17905,7 +17888,9 @@ impl Editor {
         let Some(project) = self.project.clone() else {
             return;
         };
-
+        let Some(buffer) = self.buffer.read(cx).as_singleton() else {
+            return;
+        };
         if !self.inline_value_cache.enabled {
             let inlays = std::mem::take(&mut self.inline_value_cache.inlays);
             self.splice_inlays(&inlays, Vec::new(), cx);
@@ -17923,24 +17908,15 @@ impl Editor {
                 .ok()?;
 
             let inline_values = editor
-                .update(cx, |editor, cx| {
+                .update(cx, |_, cx| {
                     let Some(current_execution_position) = current_execution_position else {
                         return Some(Task::ready(Ok(Vec::new())));
                     };
 
-                    let buffer = editor.buffer.read_with(cx, |buffer, cx| {
-                        let snapshot = buffer.snapshot(cx);
-
-                        let excerpt = snapshot.excerpt_containing(
-                            current_execution_position..current_execution_position,
-                        )?;
-
-                        editor.buffer.read(cx).buffer(excerpt.buffer_id())
-                    })?;
-
+                    // todo(debugger) when introducing multi buffer inline values check execution position's buffer id to make sure the text
+                    // anchor is in the same buffer
                     let range =
                         buffer.read(cx).anchor_before(0)..current_execution_position.text_anchor;
-
                     project.inline_values(buffer, range, cx)
                 })
                 .ok()
@@ -19884,15 +19860,9 @@ fn snippet_completions(
                             filter_range: 0..matching_prefix.len(),
                         },
                         icon_path: None,
-                        documentation: Some(
-                            CompletionDocumentation::SingleLineAndMultiLinePlainText {
-                                single_line: snippet.name.clone().into(),
-                                plain_text: snippet
-                                    .description
-                                    .clone()
-                                    .map(|description| description.into()),
-                            },
-                        ),
+                        documentation: snippet.description.clone().map(|description| {
+                            CompletionDocumentation::SingleLine(description.into())
+                        }),
                         insert_text_mode: None,
                         confirm: None,
                     })

crates/editor/src/editor_settings.rs

@@ -4,7 +4,6 @@ use project::project_settings::DiagnosticSeverity;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use settings::{Settings, SettingsSources, VsCodeSettings};
-use util::serde::default_true;
 
 #[derive(Deserialize, Clone)]
 pub struct EditorSettings {
@@ -277,9 +276,6 @@ pub enum ScrollBeyondLastLine {
 /// Default options for buffer and project search items.
 #[derive(Copy, Clone, Default, Debug, Serialize, Deserialize, JsonSchema, PartialEq, Eq)]
 pub struct SearchSettings {
-    /// Whether to show the project search button in the status bar.
-    #[serde(default = "default_true")]
-    pub button: bool,
     #[serde(default)]
     pub whole_word: bool,
     #[serde(default)]
@@ -332,7 +328,6 @@ pub enum SnippetSortOrder {
 }
 
 #[derive(Clone, Default, Serialize, Deserialize, JsonSchema)]
-#[schemars(deny_unknown_fields)]
 pub struct EditorSettingsContent {
     /// Whether the cursor blinks in the editor.
     ///
@@ -369,9 +364,9 @@ pub struct EditorSettingsContent {
     ///
     /// Default: true
     pub hover_popover_enabled: Option<bool>,
-    /// Time to wait in milliseconds before showing the informational hover box.
+    /// Time to wait before showing the informational hover box
     ///
-    /// Default: 300
+    /// Default: 350
     pub hover_popover_delay: Option<u64>,
     /// Toolbar related settings
     pub toolbar: Option<ToolbarContent>,

crates/editor/src/editor_tests.rs

@@ -16520,7 +16520,7 @@ async fn test_indent_guide_tabs(cx: &mut TestAppContext) {
     assert_indent_guides(
         0..6,
         vec![
-            indent_guide(buffer_id, 1, 5, 0),
+            indent_guide(buffer_id, 1, 6, 0),
             indent_guide(buffer_id, 3, 4, 1),
         ],
         None,

crates/editor/src/element.rs

@@ -4451,7 +4451,7 @@ impl EditorElement {
         let target_y = selection_row.as_f32() * line_height - scroll_pixel_position.y;
         let target_point = content_origin + point(target_x, target_y);
 
-        let actual_size = element.layout_as_root(Size::<AvailableSpace>::default(), window, cx);
+        let actual_size = element.layout_as_root(max_size.into(), window, cx);
         let overall_height = actual_size.height + HOVER_POPOVER_GAP;
 
         let popover_origin = if target_point.y > overall_height {

crates/eval/src/eval.rs

@@ -711,9 +711,9 @@ fn print_report(
         .values()
         .flat_map(|results| {
             results.iter().map(|(example, _)| {
-                let absolute_path = run_dir.join(example.run_directory.join("last.messages.json"));
-                let cwd = std::env::current_dir().expect("Can't get current dir");
-                pathdiff::diff_paths(&absolute_path, cwd).unwrap_or_else(|| absolute_path.clone())
+                let absolute_path = example.run_directory.join("last.messages.json");
+                pathdiff::diff_paths(&absolute_path, run_dir)
+                    .unwrap_or_else(|| absolute_path.clone())
             })
         })
         .collect::<Vec<_>>();

crates/eval/src/example.rs

@@ -48,7 +48,6 @@ pub struct ExampleMetadata {
     pub language_server: Option<LanguageServer>,
     pub max_assertions: Option<usize>,
     pub profile_id: AgentProfileId,
-    pub existing_thread_json: Option<String>,
 }
 
 #[derive(Clone, Debug)]
@@ -478,16 +477,12 @@ impl Response {
         tool_name: &'static str,
         cx: &mut ExampleContext,
     ) -> Result<&ToolUse> {
-        let result = self.find_tool_call(tool_name);
-        cx.assert_some(result, format!("called `{}`", tool_name))
-    }
-
-    pub fn find_tool_call(&self, tool_name: &str) -> Option<&ToolUse> {
-        self.messages.iter().rev().find_map(|msg| {
+        let result = self.messages.iter().find_map(|msg| {
             msg.tool_use
                 .iter()
                 .find(|tool_use| tool_use.name == tool_name)
-        })
+        });
+        cx.assert_some(result, format!("called `{}`", tool_name))
     }
 
     #[allow(dead_code)]

crates/eval/src/examples/add_arg_to_trait_method.rs

@@ -21,7 +21,6 @@ impl Example for AddArgToTraitMethod {
             }),
             max_assertions: None,
             profile_id: AgentProfileId::default(),
-            existing_thread_json: None,
         }
     }
 

crates/eval/src/examples/code_block_citations.rs

@@ -22,7 +22,6 @@ impl Example for CodeBlockCitations {
             }),
             max_assertions: None,
             profile_id: AgentProfileId::default(),
-            existing_thread_json: None,
         }
     }
 

crates/eval/src/examples/comment_translation.rs

@@ -1,7 +1,7 @@
 use crate::example::{Example, ExampleContext, ExampleMetadata, JudgeAssertion};
 use anyhow::Result;
 use assistant_settings::AgentProfileId;
-use assistant_tools::{EditFileMode, EditFileToolInput};
+use assistant_tools::EditFileToolInput;
 use async_trait::async_trait;
 
 pub struct CommentTranslation;
@@ -16,7 +16,6 @@ impl Example for CommentTranslation {
             language_server: None,
             max_assertions: Some(1),
             profile_id: AgentProfileId::default(),
-            existing_thread_json: None,
         }
     }
 
@@ -36,7 +35,7 @@ impl Example for CommentTranslation {
                 for tool_use in thread.tool_uses_for_message(message.id, cx) {
                     if tool_use.name == "edit_file" {
                         let input: EditFileToolInput = serde_json::from_value(tool_use.input)?;
-                        if !matches!(input.mode, EditFileMode::Edit) {
+                        if input.create_or_overwrite {
                             create_or_overwrite_count += 1;
                         }
                     }

crates/eval/src/examples/file_search.rs

@@ -18,7 +18,6 @@ impl Example for FileSearchExample {
             language_server: None,
             max_assertions: Some(3),
             profile_id: AgentProfileId::default(),
-            existing_thread_json: None,
         }
     }
 

crates/eval/src/examples/mod.rs

@@ -16,7 +16,6 @@ mod add_arg_to_trait_method;
 mod code_block_citations;
 mod comment_translation;
 mod file_search;
-mod overwrite_file;
 mod planets;
 
 pub fn all(examples_dir: &Path) -> Vec<Rc<dyn Example>> {
@@ -26,7 +25,6 @@ pub fn all(examples_dir: &Path) -> Vec<Rc<dyn Example>> {
         Rc::new(code_block_citations::CodeBlockCitations),
         Rc::new(planets::Planets),
         Rc::new(comment_translation::CommentTranslation),
-        Rc::new(overwrite_file::FileOverwriteExample),
     ];
 
     for example_path in list_declarative_examples(examples_dir).unwrap() {
@@ -47,7 +45,6 @@ impl DeclarativeExample {
     pub fn load(example_path: &Path) -> Result<Self> {
         let name = Self::name_from_path(example_path);
         let base: ExampleToml = toml::from_str(&fs::read_to_string(&example_path)?)?;
-        let example_dir = example_path.parent().unwrap();
 
         let language_server = if base.require_lsp {
             Some(crate::example::LanguageServer {
@@ -66,14 +63,6 @@ impl DeclarativeExample {
             AgentProfileId::default()
         };
 
-        let existing_thread_json = if let Some(path) = base.existing_thread_path {
-            let content = fs::read_to_string(example_dir.join(&path))
-                .unwrap_or_else(|_| panic!("Failed to read existing thread file: {}", path));
-            Some(content)
-        } else {
-            None
-        };
-
         let metadata = ExampleMetadata {
             name,
             url: base.url,
@@ -81,7 +70,6 @@ impl DeclarativeExample {
             language_server,
             max_assertions: None,
             profile_id,
-            existing_thread_json,
         };
 
         Ok(DeclarativeExample {
@@ -122,8 +110,6 @@ pub struct ExampleToml {
     pub diff_assertions: BTreeMap<String, String>,
     #[serde(default)]
     pub thread_assertions: BTreeMap<String, String>,
-    #[serde(default)]
-    pub existing_thread_path: Option<String>,
 }
 
 #[async_trait(?Send)]

crates/eval/src/examples/no_tools_enabled.toml

@@ -1,19 +0,0 @@
-url = "https://github.com/zed-industries/zed"
-revision = "main"
-require_lsp = false
-prompt = """
-I need to explore the codebase to understand what files are available in the project. What can you tell me about the structure of the codebase?
-
-Please find all uses of the 'find_path' function in the src directory.
-
-Also, can you tell me what the capital of France is? And how does garbage collection work in programming languages?
-"""
-
-profile_name = "minimal"
-
-[thread_assertions]
-no_hallucinated_tool_calls = """The agent should not hallucinate tool calls - for example, by writing markdown code blocks that simulate commands like `find`, `grep`, `ls`, etc. - since no tools are available. However, it is totally fine if the agent describes to the user what should be done, e.g. telling the user \"You can run `find` to...\" etc."""
-
-doesnt_hallucinate_file_paths = """The agent should not make up file paths or pretend to know the structure of the project when tools are not available."""
-
-correctly_answers_general_questions = """The agent should correctly answer general knowledge questions about the capital of France and garbage collection without asking for more context, demonstrating it can still be helpful with areas it knows about."""

crates/eval/src/examples/overwrite_file.rs

@@ -1,49 +0,0 @@
-use anyhow::Result;
-use assistant_settings::AgentProfileId;
-use assistant_tools::{EditFileMode, EditFileToolInput};
-use async_trait::async_trait;
-
-use crate::example::{Example, ExampleContext, ExampleMetadata};
-
-pub struct FileOverwriteExample;
-
-/*
-This eval tests a fix for a destructive behavior of the `edit_file` tool.
-Previously, it would rewrite existing files too aggressively, which often
-resulted in content loss.
-
-Pass rate before the fix: 10%
-Pass rate after the fix:  100%
-*/
-
-#[async_trait(?Send)]
-impl Example for FileOverwriteExample {
-    fn meta(&self) -> ExampleMetadata {
-        let thread_json = include_str!("threads/overwrite-file.json");
-
-        ExampleMetadata {
-            name: "file_overwrite".to_string(),
-            url: "https://github.com/zed-industries/zed.git".to_string(),
-            revision: "023a60806a8cc82e73bd8d88e63b4b07fc7a0040".to_string(),
-            language_server: None,
-            max_assertions: Some(1),
-            profile_id: AgentProfileId::default(),
-            existing_thread_json: Some(thread_json.to_string()),
-        }
-    }
-
-    async fn conversation(&self, cx: &mut ExampleContext) -> Result<()> {
-        let response = cx.run_turns(1).await?;
-        let file_overwritten = if let Some(tool_use) = response.find_tool_call("edit_file") {
-            let input = tool_use.parse_input::<EditFileToolInput>()?;
-            match input.mode {
-                EditFileMode::Edit => false,
-                EditFileMode::Create | EditFileMode::Overwrite => true,
-            }
-        } else {
-            false
-        };
-
-        cx.assert(!file_overwritten, "File should be edited, not overwritten")
-    }
-}

crates/eval/src/examples/planets.rs

@@ -18,7 +18,6 @@ impl Example for Planets {
             language_server: None,
             max_assertions: None,
             profile_id: AgentProfileId::default(),
-            existing_thread_json: None,
         }
     }
 

crates/eval/src/examples/threads/overwrite-file.json

@@ -1,262 +0,0 @@
-{
-  "completion_mode": "normal",
-  "cumulative_token_usage": {
-    "cache_creation_input_tokens": 18383,
-    "cache_read_input_tokens": 97250,
-    "input_tokens": 45,
-    "output_tokens": 776
-  },
-  "detailed_summary_state": "NotGenerated",
-  "exceeded_window_error": null,
-  "initial_project_snapshot": {
-    "timestamp": "2025-05-08T14:31:16.701157512Z",
-    "unsaved_buffer_paths": [],
-    "worktree_snapshots": [
-      {
-        "git_state": {
-          "current_branch": null,
-          "diff": "diff --git a/crates/language_model_selector/src/language_model_selector.rs b/crates/language_model_selector/src/language_model_selector.rs\nindex 6775bee98a..e25c9e1415 100644\n--- a/crates/language_model_selector/src/language_model_selector.rs\n+++ b/crates/language_model_selector/src/language_model_selector.rs\n@@ -410,7 +410,8 @@ impl ModelMatcher {\n     }\n \n     pub fn is_match(self: &Self, info: &ModelInfo) -> bool {\n-        self.matched_ids.contains(&info.model.id().0)\n+        let q = (info.model.provider_id(), info.model.id());\n+        self.matched_models.contains(&q)\n     }\n }\n \n",
-          "head_sha": "9245656485e58a5d6d717d82209bc8c57cb9c539",
-          "remote_url": "git@github.com:zed-industries/zed.git"
-        },
-        "worktree_path": "/home/silver/develop/zed"
-      }
-    ]
-  },
-  "messages": [
-    {
-      "context": "\n<context>\nThe following items were attached by the user. They are up-to-date and don't need to be re-read.\n\n<files>\n```rs zed/crates/language_model_selector/src/language_model_selector.rs\nconst TRY_ZED_PRO_URL [L28]\ntype OnModelChanged [L30]\ntype GetActiveModel [L31]\npub struct LanguageModelSelector [L33-37]\n picker [L34]\n _authenticate_all_providers_task [L35]\n _subscriptions [L36]\nimpl LanguageModelSelector [L39-231]\n pub fn new [L40-81]\n fn handle_language_model_registry_event [L83-104]\n fn authenticate_all_providers [L110-154]\n fn all_models [L156-204]\n pub fn active_model [L206-208]\n fn get_active_model_index [L210-230]\nimpl EventEmitter<DismissEvent> for LanguageModelSelector [L233]\nimpl Focusable for LanguageModelSelector [L235-239]\n fn focus_handle [L236-238]\nimpl Render for LanguageModelSelector [L241-245]\n fn render [L242-244]\npub struct LanguageModelSelectorPopoverMenu [L248-258]\n language_model_selector [L253]\n trigger [L254]\n tooltip [L255]\n handle [L256]\n anchor [L257]\nimpl LanguageModelSelectorPopoverMenu<T, TT> [L260-284]\n pub fn new [L265-278]\n pub fn with_handle [L280-283]\nimpl RenderOnce for LanguageModelSelectorPopoverMenu<T, TT> [L286-304]\n fn render [L291-303]\nstruct ModelInfo [L307-310]\n model [L308]\n icon [L309]\npub struct LanguageModelPickerDelegate [L312-319]\n language_model_selector [L313]\n on_model_changed [L314]\n get_active_model [L315]\n all_models [L316]\n filtered_entries [L317]\n selected_index [L318]\nstruct GroupedModels [L321-324]\n recommended [L322]\n other [L323]\nimpl GroupedModels [L326-385]\n pub fn new [L327-342]\n fn entries [L344-370]\n fn model_infos [L372-384]\nenum LanguageModelPickerEntry [L387-390]\n Model [L388]\n Separator [L389]\nstruct ModelMatcher [L392-396]\n models [L393]\n bg_executor [L394]\n candidates [L395]\nimpl ModelMatcher [L398-452]\n fn new [L399-406]\n pub fn fuzzy_search [L408-424]\n pub fn exact_search [L426-438]\n fn make_match_candidates [L440-451]\nimpl PickerDelegate for LanguageModelPickerDelegate [L454-693]\n type ListItem [L455]\n fn match_count [L457-459]\n fn selected_index [L461-463]\n fn set_selected_index [L465-468]\n fn can_select [L470-480]\n fn placeholder_text [L482-484]\n fn update_matches [L486-546]\n fn confirm [L548-560]\n fn dismissed [L562-566]\n fn render_match [L568-636]\n fn render_footer [L638-692]\n\nShowing symbols 1-71 (total symbols: 71)\n\n```\n</files>\n</context>\n",
-      "creases": [
-        {
-          "end": 140,
-          "icon_path": "icons/file_icons/rust.svg",
-          "label": "language_model_selector.rs",
-          "start": 38
-        }
-      ],
-      "id": 0,
-      "role": "user",
-      "segments": [
-        {
-          "text": "I recently introduced fuzzy search in [@language_model_selector.rs](@file:zed/crates/language_model_selector/src/language_model_selector.rs). Can you write unit-test that check it? You can find a test list of models on images. ",
-          "type": "text"
-        }
-      ],
-      "tool_results": [],
-      "tool_uses": []
-    },
-    {
-      "context": "",
-      "creases": [],
-      "id": 1,
-      "role": "assistant",
-      "segments": [
-        {
-          "text": "I'll help you write unit tests for the fuzzy search functionality in the language model selector. I see that you want to test the fuzzy search with the models shown in the images - both Claude models (3, 3.5, 3.7) and GPT models (GPT-3.5, GPT-4, GPT-4o, etc.).\n\nLet's start by examining the code structure to understand how the fuzzy search works.",
-          "type": "text"
-        }
-      ],
-      "tool_results": [
-        {
-          "content": "zed/crates/language_model_selector/Cargo.toml\nzed/crates/language_model_selector/LICENSE-GPL\nzed/crates/language_model_selector/src\n",
-          "is_error": false,
-          "output": null,
-          "tool_use_id": "toolu_01FvYMtHs763GL1wA5mpTpqn"
-        }
-      ],
-      "tool_uses": [
-        {
-          "id": "toolu_01FvYMtHs763GL1wA5mpTpqn",
-          "input": {
-            "path": "zed/crates/language_model_selector"
-          },
-          "name": "list_directory"
-        }
-      ]
-    },
-    {
-      "context": "",
-      "creases": [],
-      "id": 2,
-      "role": "assistant",
-      "segments": [
-        {
-          "text": "Let's look at the structure of the tests directory or see if there are existing tests:",
-          "type": "text"
-        }
-      ],
-      "tool_results": [
-        {
-          "content": "zed/crates/language_model_selector/src/language_model_selector.rs\n",
-          "is_error": false,
-          "output": null,
-          "tool_use_id": "toolu_01KSLDsLLrf7tgixB1sge3cm"
-        }
-      ],
-      "tool_uses": [
-        {
-          "id": "toolu_01KSLDsLLrf7tgixB1sge3cm",
-          "input": {
-            "path": "zed/crates/language_model_selector/src"
-          },
-          "name": "list_directory"
-        }
-      ]
-    },
-    {
-      "context": "",
-      "creases": [],
-      "id": 3,
-      "role": "assistant",
-      "segments": [
-        {
-          "text": "Let's check the Cargo.toml to understand the dependencies:",
-          "type": "text"
-        }
-      ],
-      "tool_results": [
-        {
-          "content": "[package]\nname = \"language_model_selector\"\nversion = \"0.1.0\"\nedition.workspace = true\npublish.workspace = true\nlicense = \"GPL-3.0-or-later\"\n\n[lints]\nworkspace = true\n\n[lib]\npath = \"src/language_model_selector.rs\"\n\n[dependencies]\ncollections.workspace = true\nfeature_flags.workspace = true\nfuzzy.workspace = true\ngpui.workspace = true\nlanguage_model.workspace = true\nlog.workspace = true\npicker.workspace = true\nproto.workspace = true\nui.workspace = true\nworkspace-hack.workspace = true\nzed_actions.workspace = true\n",
-          "is_error": false,
-          "output": null,
-          "tool_use_id": "toolu_019Je2MLfJhpJr93g5igoRAH"
-        }
-      ],
-      "tool_uses": [
-        {
-          "id": "toolu_019Je2MLfJhpJr93g5igoRAH",
-          "input": {
-            "path": "zed/crates/language_model_selector/Cargo.toml"
-          },
-          "name": "read_file"
-        }
-      ]
-    },
-    {
-      "context": "",
-      "creases": [],
-      "id": 4,
-      "role": "assistant",
-      "segments": [
-        {
-          "text": "Now let's look at the fuzzy search implementation in detail:",
-          "type": "text"
-        }
-      ],
-      "tool_results": [
-        {
-          "content": "struct ModelMatcher {\n    models: Vec<ModelInfo>,\n    bg_executor: BackgroundExecutor,\n    candidates: Vec<StringMatchCandidate>,\n}\n\nimpl ModelMatcher {\n    fn new(models: Vec<ModelInfo>, bg_executor: BackgroundExecutor) -> ModelMatcher {\n        let candidates = Self::make_match_candidates(&models);\n        Self {\n            models,\n            bg_executor,\n            candidates,\n        }\n    }\n\n    pub fn fuzzy_search(&self, query: &str) -> Vec<ModelInfo> {\n        let matches = self.bg_executor.block(match_strings(\n            &self.candidates,\n            &query,\n            false,\n            100,\n            &Default::default(),\n            self.bg_executor.clone(),\n        ));\n\n        let matched_models: Vec<_> = matches\n            .into_iter()\n            .map(|m| self.models[m.candidate_id].clone())\n            .collect();\n\n        matched_models\n    }\n\n    pub fn exact_search(&self, query: &str) -> Vec<ModelInfo> {\n        self.models\n            .iter()\n            .filter(|m| {\n                m.model\n                    .name()\n                    .0\n                    .to_lowercase()\n                    .contains(&query.to_lowercase())\n            })\n            .cloned()\n            .collect::<Vec<_>>()\n    }\n\n    fn make_match_candidates(model_infos: &Vec<ModelInfo>) -> Vec<StringMatchCandidate> {\n        model_infos\n            .iter()\n            .enumerate()\n            .map(|(index, model)| {\n                StringMatchCandidate::new(\n                    index,\n                    &format!(\"{}/{}\", &model.model.provider_id().0, &model.model.name().0),\n                )\n            })\n            .collect::<Vec<_>>()\n    }\n}",
-          "is_error": false,
-          "output": null,
-          "tool_use_id": "toolu_01GpKFEn6hYrXGiS5yBF3urk"
-        }
-      ],
-      "tool_uses": [
-        {
-          "id": "toolu_01GpKFEn6hYrXGiS5yBF3urk",
-          "input": {
-            "end_line": 452,
-            "path": "zed/crates/language_model_selector/src/language_model_selector.rs",
-            "start_line": 392
-          },
-          "name": "read_file"
-        }
-      ]
-    },
-    {
-      "context": "",
-      "creases": [],
-      "id": 5,
-      "role": "assistant",
-      "segments": [
-        {
-          "text": "Let's now check if there's an existing test module:",
-          "type": "text"
-        }
-      ],
-      "tool_results": [
-        {
-          "content": "No matches found",
-          "is_error": false,
-          "output": null,
-          "tool_use_id": "toolu_01RZAvFvpMq16Dwh6d6cnVzy"
-        }
-      ],
-      "tool_uses": [
-        {
-          "id": "toolu_01RZAvFvpMq16Dwh6d6cnVzy",
-          "input": {
-            "include_pattern": "zed/crates/language_model_selector/**/*.rs",
-            "regex": "mod tests"
-          },
-          "name": "grep"
-        }
-      ]
-    },
-    {
-      "context": "",
-      "creases": [],
-      "id": 6,
-      "role": "assistant",
-      "segments": [
-        {
-          "text": "Now I'll create a test module for the ModelMatcher's fuzzy search functionality. Let's create this test module:",
-          "type": "text"
-        }
-      ],
-      "tool_results": [],
-      "tool_uses": []
-    }
-  ],
-  "model": {
-    "model": "claude-3-7-sonnet-latest",
-    "provider": "zed.dev"
-  },
-  "profile": "Write",
-  "request_token_usage": [
-    {
-      "cache_creation_input_tokens": 9581,
-      "input_tokens": 4,
-      "output_tokens": 5
-    },
-    {
-      "cache_creation_input_tokens": 204,
-      "cache_read_input_tokens": 9581,
-      "input_tokens": 6,
-      "output_tokens": 5
-    },
-    {
-      "cache_creation_input_tokens": 104,
-      "cache_read_input_tokens": 9785,
-      "input_tokens": 6,
-      "output_tokens": 5
-    },
-    {
-      "cache_creation_input_tokens": 239,
-      "cache_read_input_tokens": 9889,
-      "input_tokens": 6,
-      "output_tokens": 5
-    },
-    {
-      "cache_creation_input_tokens": 569,
-      "cache_read_input_tokens": 10128,
-      "input_tokens": 5,
-      "output_tokens": 5
-    },
-    {
-      "cache_creation_input_tokens": 87,
-      "cache_read_input_tokens": 10697,
-      "input_tokens": 5,
-      "output_tokens": 2
-    },
-    {
-      "cache_creation_input_tokens": 7355,
-      "cache_read_input_tokens": 10784,
-      "input_tokens": 5,
-      "output_tokens": 3
-    }
-  ],
-  "summary": "Fuzzy Search Testing Language Model Selector",
-  "updated_at": "2025-05-08T18:20:34.205405751Z",
-  "version": "0.2.0"
-}

crates/eval/src/instance.rs

@@ -1,4 +1,4 @@
-use agent::{Message, MessageSegment, SerializedThread, ThreadStore};
+use agent::{Message, MessageSegment, ThreadStore};
 use anyhow::{Context, Result, anyhow, bail};
 use assistant_tool::ToolWorkingSet;
 use client::proto::LspWorkProgress;
@@ -9,7 +9,7 @@ use handlebars::Handlebars;
 use language::{Buffer, DiagnosticSeverity, OffsetRangeExt as _};
 use language_model::{
     LanguageModel, LanguageModelCompletionEvent, LanguageModelRequest, LanguageModelRequestMessage,
-    LanguageModelToolResultContent, MessageContent, Role, TokenUsage,
+    MessageContent, Role, TokenUsage,
 };
 use project::lsp_store::OpenLspBufferHandle;
 use project::{DiagnosticSummary, Project, ProjectPath};
@@ -312,14 +312,7 @@ impl ExampleInstance {
             thread_store.update(cx, |thread_store, cx| thread_store.load_profile_by_id(profile_id, cx)).expect("Failed to load profile");
 
             let thread =
-                thread_store.update(cx, |thread_store, cx| {
-                    if let Some(json) = &meta.existing_thread_json {
-                        let serialized = SerializedThread::from_json(json.as_bytes()).expect("Can't read serialized thread");
-                        thread_store.create_thread_from_serialized(serialized, cx)
-                    } else {
-                        thread_store.create_thread(cx)
-                    }
-                })?;
+                thread_store.update(cx, |thread_store, cx| thread_store.create_thread(cx))?;
 
 
             thread.update(cx, |thread, _cx| {
@@ -971,15 +964,7 @@ impl RequestMarkdown {
                         if tool_result.is_error {
                             messages.push_str("**ERROR:**\n");
                         }
-
-                        match &tool_result.content {
-                            LanguageModelToolResultContent::Text(str) => {
-                                writeln!(messages, "{}\n", str).ok();
-                            }
-                            LanguageModelToolResultContent::Image(image) => {
-                                writeln!(messages, "![Image](data:base64,{})\n", image.source).ok();
-                            }
-                        }
+                        messages.push_str(&format!("{}\n\n", tool_result.content));
 
                         if let Some(output) = tool_result.output.as_ref() {
                             writeln!(

crates/extension/Cargo.toml

@@ -17,7 +17,6 @@ async-compression.workspace = true
 async-tar.workspace = true
 async-trait.workspace = true
 collections.workspace = true
-dap.workspace = true
 fs.workspace = true
 futures.workspace = true
 gpui.workspace = true
@@ -30,7 +29,6 @@ parking_lot.workspace = true
 semantic_version.workspace = true
 serde.workspace = true
 serde_json.workspace = true
-task.workspace = true
 toml.workspace = true
 util.workspace = true
 wasm-encoder.workspace = true

crates/extension/src/extension.rs

@@ -135,13 +135,6 @@ pub trait Extension: Send + Sync + 'static {
         package_name: Arc<str>,
         kv_store: Arc<dyn KeyValueStoreDelegate>,
     ) -> Result<()>;
-
-    async fn get_dap_binary(
-        &self,
-        dap_name: Arc<str>,
-        config: DebugTaskDefinition,
-        user_installed_path: Option<PathBuf>,
-    ) -> Result<DebugAdapterBinary>;
 }
 
 pub fn parse_wasm_extension_version(

crates/extension/src/extension_host_proxy.rs

@@ -29,7 +29,6 @@ pub struct ExtensionHostProxy {
     slash_command_proxy: RwLock<Option<Arc<dyn ExtensionSlashCommandProxy>>>,
     context_server_proxy: RwLock<Option<Arc<dyn ExtensionContextServerProxy>>>,
     indexed_docs_provider_proxy: RwLock<Option<Arc<dyn ExtensionIndexedDocsProviderProxy>>>,
-    debug_adapter_provider_proxy: RwLock<Option<Arc<dyn ExtensionDebugAdapterProviderProxy>>>,
 }
 
 impl ExtensionHostProxy {
@@ -55,7 +54,6 @@ impl ExtensionHostProxy {
             slash_command_proxy: RwLock::default(),
             context_server_proxy: RwLock::default(),
             indexed_docs_provider_proxy: RwLock::default(),
-            debug_adapter_provider_proxy: RwLock::default(),
         }
     }
 
@@ -95,11 +93,6 @@ impl ExtensionHostProxy {
             .write()
             .replace(Arc::new(proxy));
     }
-    pub fn register_debug_adapter_proxy(&self, proxy: impl ExtensionDebugAdapterProviderProxy) {
-        self.debug_adapter_provider_proxy
-            .write()
-            .replace(Arc::new(proxy));
-    }
 }
 
 pub trait ExtensionThemeProxy: Send + Sync + 'static {
@@ -409,17 +402,3 @@ impl ExtensionIndexedDocsProviderProxy for ExtensionHostProxy {
         proxy.register_indexed_docs_provider(extension, provider_id)
     }
 }
-
-pub trait ExtensionDebugAdapterProviderProxy: Send + Sync + 'static {
-    fn register_debug_adapter(&self, extension: Arc<dyn Extension>, debug_adapter_name: Arc<str>);
-}
-
-impl ExtensionDebugAdapterProviderProxy for ExtensionHostProxy {
-    fn register_debug_adapter(&self, extension: Arc<dyn Extension>, debug_adapter_name: Arc<str>) {
-        let Some(proxy) = self.debug_adapter_provider_proxy.read().clone() else {
-            return;
-        };
-
-        proxy.register_debug_adapter(extension, debug_adapter_name)
-    }
-}

crates/extension/src/types.rs

@@ -1,12 +1,10 @@
 mod context_server;
-mod dap;
 mod lsp;
 mod slash_command;
 
 use std::ops::Range;
 
 pub use context_server::*;
-pub use dap::*;
 pub use lsp::*;
 pub use slash_command::*;
 

crates/extension/src/types/dap.rs

@@ -1,5 +0,0 @@
-pub use dap::{
-    StartDebuggingRequestArguments, StartDebuggingRequestArgumentsRequest,
-    adapters::{DebugAdapterBinary, DebugTaskDefinition, TcpArguments},
-};
-pub use task::{AttachRequest, DebugRequest, LaunchRequest, TcpArgumentsTemplate};

crates/extension_api/Cargo.toml

@@ -1,13 +1,12 @@
 [package]
 name = "zed_extension_api"
-version = "0.6.0"
+version = "0.5.0"
 description = "APIs for creating Zed extensions in Rust"
 repository = "https://github.com/zed-industries/zed"
 documentation = "https://docs.rs/zed_extension_api"
 keywords = ["zed", "extension"]
 edition.workspace = true
-# Change back to `true` when we're ready to publish v0.6.0.
-publish = false
+publish = true
 license = "Apache-2.0"
 
 [lints]

crates/extension_api/src/extension_api.rs

@@ -187,16 +187,6 @@ pub trait Extension: Send + Sync {
     ) -> Result<(), String> {
         Err("`index_docs` not implemented".to_string())
     }
-
-    /// Returns the debug adapter binary for the specified adapter name and configuration.
-    fn get_dap_binary(
-        &mut self,
-        _adapter_name: String,
-        _config: DebugTaskDefinition,
-        _user_provided_path: Option<String>,
-    ) -> Result<DebugAdapterBinary, String> {
-        Err("`get_dap_binary` not implemented".to_string())
-    }
 }
 
 /// Registers the provided type as a Zed extension.
@@ -238,7 +228,7 @@ mod wit {
 
     wit_bindgen::generate!({
         skip: ["init-extension"],
-        path: "./wit/since_v0.6.0",
+        path: "./wit/since_v0.5.0",
     });
 }
 
@@ -381,14 +371,6 @@ impl wit::Guest for Component {
     ) -> Result<(), String> {
         extension().index_docs(provider, package, database)
     }
-
-    fn get_dap_binary(
-        adapter_name: String,
-        config: DebugTaskDefinition,
-        user_installed_path: Option<String>,
-    ) -> Result<DebugAdapterBinary, String> {
-        extension().get_dap_binary(adapter_name, config, user_installed_path)
-    }
 }
 
 /// The ID of a language server.

crates/extension_api/wit/since_v0.6.0/common.wit

@@ -1,12 +0,0 @@
-interface common {
-    /// A (half-open) range (`[start, end)`).
-    record range {
-        /// The start of the range (inclusive).
-        start: u32,
-        /// The end of the range (exclusive).
-        end: u32,
-    }
-
-    /// A list of environment variables.
-    type env-vars = list<tuple<string, string>>;
-}

crates/extension_api/wit/since_v0.6.0/context-server.wit

@@ -1,11 +0,0 @@
-interface context-server {
-    /// Configuration for context server setup and installation.
-    record context-server-configuration {
-        /// Installation instructions in Markdown format.
-        installation-instructions: string,
-        /// JSON schema for settings validation.
-        settings-schema: string,
-        /// Default settings template.
-        default-settings: string,
-    }
-}

crates/extension_api/wit/since_v0.6.0/dap.wit

@@ -1,56 +0,0 @@
-interface dap {
-    use common.{env-vars};
-    record launch-request {
-        program: string,
-        cwd: option<string>,
-        args: list<string>,
-        envs: env-vars,
-    }
-
-    record attach-request {
-        process-id: option<u32>,
-    }
-
-    variant debug-request {
-        launch(launch-request),
-        attach(attach-request)
-    }
-
-    record tcp-arguments {
-        port: u16,
-        host: u32,
-        timeout: option<u64>,
-    }
-
-    record tcp-arguments-template {
-        port: option<u16>,
-        host: option<u32>,
-        timeout: option<u64>,
-    }
-    record debug-task-definition {
-        label: string,
-        adapter: string,
-        request: debug-request,
-        initialize-args: option<string>,
-        stop-on-entry: option<bool>,
-        tcp-connection: option<tcp-arguments-template>,
-    }
-
-    enum start-debugging-request-arguments-request {
-        launch,
-        attach,
-    }
-    record start-debugging-request-arguments {
-        configuration: string,
-        request: start-debugging-request-arguments-request,
-
-    }
-    record debug-adapter-binary {
-        command: string,
-        arguments: list<string>,
-        envs: env-vars,
-        cwd: option<string>,
-        connection: option<tcp-arguments>,
-        request-args: start-debugging-request-arguments
-    }
-}

crates/extension_api/wit/since_v0.6.0/extension.wit

@@ -1,161 +0,0 @@
-package zed:extension;
-
-world extension {
-    import context-server;
-    import dap;
-    import github;
-    import http-client;
-    import platform;
-    import process;
-    import nodejs;
-
-    use common.{env-vars, range};
-    use context-server.{context-server-configuration};
-    use dap.{debug-adapter-binary, debug-task-definition};
-    use lsp.{completion, symbol};
-    use process.{command};
-    use slash-command.{slash-command, slash-command-argument-completion, slash-command-output};
-
-    /// Initializes the extension.
-    export init-extension: func();
-
-    /// The type of a downloaded file.
-    enum downloaded-file-type {
-        /// A gzipped file (`.gz`).
-        gzip,
-        /// A gzipped tar archive (`.tar.gz`).
-        gzip-tar,
-        /// A ZIP file (`.zip`).
-        zip,
-        /// An uncompressed file.
-        uncompressed,
-    }
-
-    /// The installation status for a language server.
-    variant language-server-installation-status {
-        /// The language server has no installation status.
-        none,
-        /// The language server is being downloaded.
-        downloading,
-        /// The language server is checking for updates.
-        checking-for-update,
-        /// The language server installation failed for specified reason.
-        failed(string),
-    }
-
-    record settings-location {
-        worktree-id: u64,
-        path: string,
-    }
-
-    import get-settings: func(path: option<settings-location>, category: string, key: option<string>) -> result<string, string>;
-
-    /// Downloads a file from the given URL and saves it to the given path within the extension's
-    /// working directory.
-    ///
-    /// The file will be extracted according to the given file type.
-    import download-file: func(url: string, file-path: string, file-type: downloaded-file-type) -> result<_, string>;
-
-    /// Makes the file at the given path executable.
-    import make-file-executable: func(filepath: string) -> result<_, string>;
-
-    /// Updates the installation status for the given language server.
-    import set-language-server-installation-status: func(language-server-name: string, status: language-server-installation-status);
-
-    /// A Zed worktree.
-    resource worktree {
-        /// Returns the ID of the worktree.
-        id: func() -> u64;
-        /// Returns the root path of the worktree.
-        root-path: func() -> string;
-        /// Returns the textual contents of the specified file in the worktree.
-        read-text-file: func(path: string) -> result<string, string>;
-        /// Returns the path to the given binary name, if one is present on the `$PATH`.
-        which: func(binary-name: string) -> option<string>;
-        /// Returns the current shell environment.
-        shell-env: func() -> env-vars;
-    }
-
-    /// A Zed project.
-    resource project {
-        /// Returns the IDs of all of the worktrees in this project.
-        worktree-ids: func() -> list<u64>;
-    }
-
-    /// A key-value store.
-    resource key-value-store {
-        /// Inserts an entry under the specified key.
-        insert: func(key: string, value: string) -> result<_, string>;
-    }
-
-    /// Returns the command used to start up the language server.
-    export language-server-command: func(language-server-id: string, worktree: borrow<worktree>) -> result<command, string>;
-
-    /// Returns the initialization options to pass to the language server on startup.
-    ///
-    /// The initialization options are represented as a JSON string.
-    export language-server-initialization-options: func(language-server-id: string, worktree: borrow<worktree>) -> result<option<string>, string>;
-
-    /// Returns the workspace configuration options to pass to the language server.
-    export language-server-workspace-configuration: func(language-server-id: string, worktree: borrow<worktree>) -> result<option<string>, string>;
-
-    /// Returns the initialization options to pass to the other language server.
-    export language-server-additional-initialization-options: func(language-server-id: string, target-language-server-id: string, worktree: borrow<worktree>) -> result<option<string>, string>;
-
-    /// Returns the workspace configuration options to pass to the other language server.
-    export language-server-additional-workspace-configuration: func(language-server-id: string, target-language-server-id: string, worktree: borrow<worktree>) -> result<option<string>, string>;
-
-    /// A label containing some code.
-    record code-label {
-        /// The source code to parse with Tree-sitter.
-        code: string,
-        /// The spans to display in the label.
-        spans: list<code-label-span>,
-        /// The range of the displayed label to include when filtering.
-        filter-range: range,
-    }
-
-    /// A span within a code label.
-    variant code-label-span {
-        /// A range into the parsed code.
-        code-range(range),
-        /// A span containing a code literal.
-        literal(code-label-span-literal),
-    }
-
-    /// A span containing a code literal.
-    record code-label-span-literal {
-        /// The literal text.
-        text: string,
-        /// The name of the highlight to use for this literal.
-        highlight-name: option<string>,
-    }
-
-    export labels-for-completions: func(language-server-id: string, completions: list<completion>) -> result<list<option<code-label>>, string>;
-    export labels-for-symbols: func(language-server-id: string, symbols: list<symbol>) -> result<list<option<code-label>>, string>;
-
-    /// Returns the completions that should be shown when completing the provided slash command with the given query.
-    export complete-slash-command-argument: func(command: slash-command, args: list<string>) -> result<list<slash-command-argument-completion>, string>;
-
-    /// Returns the output from running the provided slash command.
-    export run-slash-command: func(command: slash-command, args: list<string>, worktree: option<borrow<worktree>>) -> result<slash-command-output, string>;
-
-    /// Returns the command used to start up a context server.
-    export context-server-command: func(context-server-id: string, project: borrow<project>) -> result<command, string>;
-
-    /// Returns the configuration for a context server.
-    export context-server-configuration: func(context-server-id: string, project: borrow<project>) -> result<option<context-server-configuration>, string>;
-
-    /// Returns a list of packages as suggestions to be included in the `/docs`
-    /// search results.
-    ///
-    /// This can be used to provide completions for known packages (e.g., from the
-    /// local project or a registry) before a package has been indexed.
-    export suggest-docs-packages: func(provider-name: string) -> result<list<string>, string>;
-
-    /// Indexes the docs for the specified package.
-    export index-docs: func(provider-name: string, package-name: string, database: borrow<key-value-store>) -> result<_, string>;
-
-    /// Returns a configured debug adapter binary for a given debug task.
-    export get-dap-binary: func(adapter-name: string, config: debug-task-definition, user-installed-path: option<string>) -> result<debug-adapter-binary, string>;
-}

crates/extension_api/wit/since_v0.6.0/github.wit

@@ -1,35 +0,0 @@
-interface github {
-    /// A GitHub release.
-    record github-release {
-        /// The version of the release.
-        version: string,
-        /// The list of assets attached to the release.
-        assets: list<github-release-asset>,
-    }
-
-    /// An asset from a GitHub release.
-    record github-release-asset {
-        /// The name of the asset.
-        name: string,
-        /// The download URL for the asset.
-        download-url: string,
-    }
-
-    /// The options used to filter down GitHub releases.
-    record github-release-options {
-        /// Whether releases without assets should be included.
-        require-assets: bool,
-        /// Whether pre-releases should be included.
-        pre-release: bool,
-    }
-
-    /// Returns the latest release for the given GitHub repository.
-    ///
-    /// Takes repo as a string in the form "<owner-name>/<repo-name>", for example: "zed-industries/zed".
-    latest-github-release: func(repo: string, options: github-release-options) -> result<github-release, string>;
-
-    /// Returns the GitHub release with the specified tag name for the given GitHub repository.
-    ///
-    /// Returns an error if a release with the given tag name does not exist.
-    github-release-by-tag-name: func(repo: string, tag: string) -> result<github-release, string>;
-}

crates/extension_api/wit/since_v0.6.0/http-client.wit

@@ -1,67 +0,0 @@
-interface http-client {
-    /// An HTTP request.
-    record http-request {
-        /// The HTTP method for the request.
-        method: http-method,
-        /// The URL to which the request should be made.
-        url: string,
-        /// The headers for the request.
-        headers: list<tuple<string, string>>,
-        /// The request body.
-        body: option<list<u8>>,
-        /// The policy to use for redirects.
-        redirect-policy: redirect-policy,
-    }
-
-    /// HTTP methods.
-    enum http-method {
-        /// `GET`
-        get,
-        /// `HEAD`
-        head,
-        /// `POST`
-        post,
-        /// `PUT`
-        put,
-        /// `DELETE`
-        delete,
-        /// `OPTIONS`
-        options,
-        /// `PATCH`
-        patch,
-    }
-
-    /// The policy for dealing with redirects received from the server.
-    variant redirect-policy {
-        /// Redirects from the server will not be followed.
-        ///
-        /// This is the default behavior.
-        no-follow,
-        /// Redirects from the server will be followed up to the specified limit.
-        follow-limit(u32),
-        /// All redirects from the server will be followed.
-        follow-all,
-    }
-
-    /// An HTTP response.
-    record http-response {
-        /// The response headers.
-        headers: list<tuple<string, string>>,
-        /// The response body.
-        body: list<u8>,
-    }
-
-    /// Performs an HTTP request and returns the response.
-    fetch: func(req: http-request) -> result<http-response, string>;
-
-    /// An HTTP response stream.
-    resource http-response-stream {
-        /// Retrieves the next chunk of data from the response stream.
-        ///
-        /// Returns `Ok(None)` if the stream has ended.
-        next-chunk: func() -> result<option<list<u8>>, string>;
-    }
-
-    /// Performs an HTTP request and returns a response stream.
-    fetch-stream: func(req: http-request) -> result<http-response-stream, string>;
-}

crates/extension_api/wit/since_v0.6.0/lsp.wit

@@ -1,90 +0,0 @@
-interface lsp {
-    /// An LSP completion.
-    record completion {
-        label: string,
-        label-details: option<completion-label-details>,
-        detail: option<string>,
-        kind: option<completion-kind>,
-        insert-text-format: option<insert-text-format>,
-    }
-
-    /// The kind of an LSP completion.
-    variant completion-kind {
-        text,
-        method,
-        function,
-        %constructor,
-        field,
-        variable,
-        class,
-        %interface,
-        module,
-        property,
-        unit,
-        value,
-        %enum,
-        keyword,
-        snippet,
-        color,
-        file,
-        reference,
-        folder,
-        enum-member,
-        constant,
-        struct,
-        event,
-        operator,
-        type-parameter,
-        other(s32),
-    }
-
-    /// Label details for an LSP completion.
-    record completion-label-details {
-        detail: option<string>,
-        description: option<string>,
-    }
-
-    /// Defines how to interpret the insert text in a completion item.
-    variant insert-text-format {
-        plain-text,
-        snippet,
-        other(s32),
-    }
-
-    /// An LSP symbol.
-    record symbol {
-        kind: symbol-kind,
-        name: string,
-    }
-
-    /// The kind of an LSP symbol.
-    variant symbol-kind {
-        file,
-        module,
-        namespace,
-        %package,
-        class,
-        method,
-        property,
-        field,
-        %constructor,
-        %enum,
-        %interface,
-        function,
-        variable,
-        constant,
-        %string,
-        number,
-        boolean,
-        array,
-        object,
-        key,
-        null,
-        enum-member,
-        struct,
-        event,
-        operator,
-        type-parameter,
-        other(s32),
-    }
-}

crates/extension_api/wit/since_v0.6.0/nodejs.wit

@@ -1,13 +0,0 @@
-interface nodejs {
-    /// Returns the path to the Node binary used by Zed.
-    node-binary-path: func() -> result<string, string>;
-
-    /// Returns the latest version of the given NPM package.
-    npm-package-latest-version: func(package-name: string) -> result<string, string>;
-
-    /// Returns the installed version of the given NPM package, if it exists.
-    npm-package-installed-version: func(package-name: string) -> result<option<string>, string>;
-
-    /// Installs the specified NPM package.
-    npm-install-package: func(package-name: string, version: string) -> result<_, string>;
-}

crates/extension_api/wit/since_v0.6.0/platform.wit

@@ -1,24 +0,0 @@
-interface platform {
-    /// An operating system.
-    enum os {
-        /// macOS.
-        mac,
-        /// Linux.
-        linux,
-        /// Windows.
-        windows,
-    }
-
-    /// A platform architecture.
-    enum architecture {
-        /// AArch64 (e.g., Apple Silicon).
-        aarch64,
-        /// x86.
-        x86,
-        /// x86-64.
-        x8664,
-    }
-
-    /// Gets the current operating system and architecture.
-    current-platform: func() -> tuple<os, architecture>;
-}