From 5f0edd38f896a2f31971d1eb53eec944adc3a0e3 Mon Sep 17 00:00:00 2001 From: Julia Ryan Date: Wed, 23 Jul 2025 13:01:16 -0500 Subject: [PATCH 001/893] Add TestPanic feature flag (#34963) Now the `dev: panic` action can be run on all release channels if the user has the feature flag enabled. Release Notes: - N/A --- Cargo.lock | 1 + crates/feature_flags/src/feature_flags.rs | 5 +++++ crates/zed/Cargo.toml | 1 + crates/zed/src/zed.rs | 20 +++++++++----------- 4 files changed, 16 insertions(+), 11 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 8be4c9d7be..6ded3ce5eb 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -20211,6 +20211,7 @@ dependencies = [ "extension", "extension_host", "extensions_ui", + "feature_flags", "feedback", "file_finder", "fs", diff --git a/crates/feature_flags/src/feature_flags.rs b/crates/feature_flags/src/feature_flags.rs index da85133bb9..631bafc841 100644 --- a/crates/feature_flags/src/feature_flags.rs +++ b/crates/feature_flags/src/feature_flags.rs @@ -85,6 +85,11 @@ impl FeatureFlag for ThreadAutoCaptureFeatureFlag { false } } +pub struct PanicFeatureFlag; + +impl FeatureFlag for PanicFeatureFlag { + const NAME: &'static str = "panic"; +} pub struct JjUiFeatureFlag {} diff --git a/crates/zed/Cargo.toml b/crates/zed/Cargo.toml index e565aba26b..1b56494145 100644 --- a/crates/zed/Cargo.toml +++ b/crates/zed/Cargo.toml @@ -56,6 +56,7 @@ env_logger.workspace = true extension.workspace = true extension_host.workspace = true extensions_ui.workspace = true +feature_flags.workspace = true feedback.workspace = true file_finder.workspace = true fs.workspace = true diff --git a/crates/zed/src/zed.rs b/crates/zed/src/zed.rs index 24c7ab5ba2..57534c8cd5 100644 --- a/crates/zed/src/zed.rs +++ b/crates/zed/src/zed.rs @@ -19,6 +19,7 @@ use collections::VecDeque; use debugger_ui::debugger_panel::DebugPanel; use editor::ProposedChangesEditorToolbar; use editor::{Editor, MultiBuffer}; +use feature_flags::{FeatureFlagAppExt, PanicFeatureFlag}; use futures::future::Either; use futures::{StreamExt, channel::mpsc, select_biased}; use git_ui::git_panel::GitPanel; @@ -53,9 +54,12 @@ use settings::{ initial_local_debug_tasks_content, initial_project_settings_content, initial_tasks_content, update_settings_file, }; -use std::path::PathBuf; -use std::sync::atomic::{self, AtomicBool}; -use std::{borrow::Cow, path::Path, sync::Arc}; +use std::{ + borrow::Cow, + path::{Path, PathBuf}, + sync::Arc, + sync::atomic::{self, AtomicBool}, +}; use terminal_view::terminal_panel::{self, TerminalPanel}; use theme::{ActiveTheme, ThemeSettings}; use ui::{PopoverMenuHandle, prelude::*}; @@ -120,11 +124,9 @@ pub fn init(cx: &mut App) { cx.on_action(quit); cx.on_action(|_: &RestoreBanner, cx| title_bar::restore_banner(cx)); - - if ReleaseChannel::global(cx) == ReleaseChannel::Dev { - cx.on_action(test_panic); + if ReleaseChannel::global(cx) == ReleaseChannel::Dev || cx.has_flag::() { + cx.on_action(|_: &TestPanic, _| panic!("Ran the TestPanic action")); } - cx.on_action(|_: &OpenLog, cx| { with_active_or_new_workspace(cx, |workspace, window, cx| { open_log_file(workspace, window, cx); @@ -987,10 +989,6 @@ fn about( .detach(); } -fn test_panic(_: &TestPanic, _: &mut App) { - panic!("Ran the TestPanic action") -} - fn install_cli( _: &mut Workspace, _: &install_cli::Install, From a48247a313adbe084abc53455f3e34f92c78cf44 Mon Sep 17 00:00:00 2001 From: "Joseph T. Lyons" Date: Wed, 23 Jul 2025 14:14:39 -0400 Subject: [PATCH 002/893] Bump Zed to v0.198 (#34964) Release Notes: -N/A --- Cargo.lock | 2 +- crates/zed/Cargo.toml | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 6ded3ce5eb..851c658735 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -20170,7 +20170,7 @@ dependencies = [ [[package]] name = "zed" -version = "0.197.0" +version = "0.198.0" dependencies = [ "activity_indicator", "agent", diff --git a/crates/zed/Cargo.toml b/crates/zed/Cargo.toml index 1b56494145..a864ece683 100644 --- a/crates/zed/Cargo.toml +++ b/crates/zed/Cargo.toml @@ -2,7 +2,7 @@ description = "The fast, collaborative code editor." edition.workspace = true name = "zed" -version = "0.197.0" +version = "0.198.0" publish.workspace = true license = "GPL-3.0-or-later" authors = ["Zed Team "] From 9863c8a44e2958d56313370f3c517b9c3ca0bfe0 Mon Sep 17 00:00:00 2001 From: Umesh Yadav <23421535+imumesh18@users.noreply.github.com> Date: Wed, 23 Jul 2025 23:58:05 +0530 Subject: [PATCH 003/893] agent_ui: Show keybindings for NewThread and NewTextThread in new thread button (#34967) I believe in this PR: #34829 we moved to context menu entry from action but the side effect of that was we also removed the Keybindings from showing it in the new thread button dropdown. This PR fixes that. cc @danilo-leal | Before | After | |--------|--------| | CleanShot 2025-07-23 at 23 36 28@2x | CleanShot 2025-07-23 at 23 37 17@2x | Release Notes: - N/A --- crates/agent_ui/src/agent_panel.rs | 167 +++++++++++++++-------------- 1 file changed, 89 insertions(+), 78 deletions(-) diff --git a/crates/agent_ui/src/agent_panel.rs b/crates/agent_ui/src/agent_panel.rs index 95ce289608..6ae2f12b5e 100644 --- a/crates/agent_ui/src/agent_panel.rs +++ b/crates/agent_ui/src/agent_panel.rs @@ -1901,85 +1901,96 @@ impl AgentPanel { ) .anchor(Corner::TopRight) .with_handle(self.new_thread_menu_handle.clone()) - .menu(move |window, cx| { - let active_thread = active_thread.clone(); - Some(ContextMenu::build(window, cx, |mut menu, _window, cx| { - menu = menu - .when(cx.has_flag::(), |this| { - this.header("Zed Agent") - }) - .item( - ContextMenuEntry::new("New Thread") - .icon(IconName::NewThread) - .icon_color(Color::Muted) - .handler(move |window, cx| { - window.dispatch_action(NewThread::default().boxed_clone(), cx); - }), - ) - .item( - ContextMenuEntry::new("New Text Thread") - .icon(IconName::NewTextThread) - .icon_color(Color::Muted) - .handler(move |window, cx| { - window.dispatch_action(NewTextThread.boxed_clone(), cx); - }), - ) - .when_some(active_thread, |this, active_thread| { - let thread = active_thread.read(cx); + .menu({ + let focus_handle = focus_handle.clone(); + move |window, cx| { + let active_thread = active_thread.clone(); + Some(ContextMenu::build(window, cx, |mut menu, _window, cx| { + menu = menu + .context(focus_handle.clone()) + .when(cx.has_flag::(), |this| { + this.header("Zed Agent") + }) + .item( + ContextMenuEntry::new("New Thread") + .icon(IconName::NewThread) + .icon_color(Color::Muted) + .action(NewThread::default().boxed_clone()) + .handler(move |window, cx| { + window.dispatch_action( + NewThread::default().boxed_clone(), + cx, + ); + }), + ) + .item( + ContextMenuEntry::new("New Text Thread") + .icon(IconName::NewTextThread) + .icon_color(Color::Muted) + .action(NewTextThread.boxed_clone()) + .handler(move |window, cx| { + window.dispatch_action(NewTextThread.boxed_clone(), cx); + }), + ) + .when_some(active_thread, |this, active_thread| { + let thread = active_thread.read(cx); - if !thread.is_empty() { - let thread_id = thread.id().clone(); - this.item( - ContextMenuEntry::new("New From Summary") - .icon(IconName::NewFromSummary) - .icon_color(Color::Muted) - .handler(move |window, cx| { - window.dispatch_action( - Box::new(NewThread { - from_thread_id: Some(thread_id.clone()), - }), - cx, - ); - }), - ) - } else { - this - } - }) - .when(cx.has_flag::(), |this| { - this.separator() - .header("External Agents") - .item( - ContextMenuEntry::new("New Gemini Thread") - .icon(IconName::AiGemini) - .icon_color(Color::Muted) - .handler(move |window, cx| { - window.dispatch_action( - NewExternalAgentThread { - agent: Some(crate::ExternalAgent::Gemini), - } - .boxed_clone(), - cx, - ); - }), - ) - .item( - ContextMenuEntry::new("New Claude Code Thread") - .icon(IconName::AiClaude) - .icon_color(Color::Muted) - .handler(move |window, cx| { - window.dispatch_action( - NewExternalAgentThread { - agent: Some(crate::ExternalAgent::ClaudeCode), - } - .boxed_clone(), - cx, - ); - }), - ) - }); - menu - })) + if !thread.is_empty() { + let thread_id = thread.id().clone(); + this.item( + ContextMenuEntry::new("New From Summary") + .icon(IconName::NewFromSummary) + .icon_color(Color::Muted) + .handler(move |window, cx| { + window.dispatch_action( + Box::new(NewThread { + from_thread_id: Some(thread_id.clone()), + }), + cx, + ); + }), + ) + } else { + this + } + }) + .when(cx.has_flag::(), |this| { + this.separator() + .header("External Agents") + .item( + ContextMenuEntry::new("New Gemini Thread") + .icon(IconName::AiGemini) + .icon_color(Color::Muted) + .handler(move |window, cx| { + window.dispatch_action( + NewExternalAgentThread { + agent: Some(crate::ExternalAgent::Gemini), + } + .boxed_clone(), + cx, + ); + }), + ) + .item( + ContextMenuEntry::new("New Claude Code Thread") + .icon(IconName::AiClaude) + .icon_color(Color::Muted) + .handler(move |window, cx| { + window.dispatch_action( + NewExternalAgentThread { + agent: Some( + crate::ExternalAgent::ClaudeCode, + ), + } + .boxed_clone(), + cx, + ); + }), + ) + }); + menu + })) + } }); let agent_panel_menu = PopoverMenu::new("agent-options-menu") From be0d9eecb72678fb25eed2abc7e781f0d9e0bb2d Mon Sep 17 00:00:00 2001 From: Nicolas Rodriguez <55200060+NRodriguezcuellar@users.noreply.github.com> Date: Wed, 23 Jul 2025 20:52:44 +0200 Subject: [PATCH 004/893] Add collapse functionality to outline entries (#33490) partly Closes #23075 Release Notes: - Now provides collapse and enables functionality to outline entries - Add a new expand_outlines_with_depth setting to customize how deep the tree is expanded by when a file is opened part 2 is in #34164 **Visual examples** ![image](https://github.com/user-attachments/assets/5dcdb83b-6e3e-4bfd-8ef4-76ae2ce4d3e6) ![image](https://github.com/user-attachments/assets/7b786a5a-1a8c-4f34-aaa5-4a8d0afa9668) ![image](https://github.com/user-attachments/assets/1817be06-ac71-4480-8f17-0bd862e913c8) --- assets/settings/default.json | 5 +- crates/outline_panel/src/outline_panel.rs | 862 +++++++++++++++++- .../src/outline_panel_settings.rs | 8 + 3 files changed, 826 insertions(+), 49 deletions(-) diff --git a/assets/settings/default.json b/assets/settings/default.json index dab1684aef..3a7a48efc2 100644 --- a/assets/settings/default.json +++ b/assets/settings/default.json @@ -691,7 +691,10 @@ // 5. Never show the scrollbar: // "never" "show": null - } + }, + // Default depth to expand outline items in the current file. + // Set to 0 to collapse all items that have children, 1 or higher to collapse items at that depth or deeper. + "expand_outlines_with_depth": 100 }, "collaboration_panel": { // Whether to show the collaboration panel button in the status bar. diff --git a/crates/outline_panel/src/outline_panel.rs b/crates/outline_panel/src/outline_panel.rs index 12dcab9e87..50c6c2dcce 100644 --- a/crates/outline_panel/src/outline_panel.rs +++ b/crates/outline_panel/src/outline_panel.rs @@ -1,19 +1,5 @@ mod outline_panel_settings; -use std::{ - cmp, - collections::BTreeMap, - hash::Hash, - ops::Range, - path::{MAIN_SEPARATOR_STR, Path, PathBuf}, - sync::{ - Arc, OnceLock, - atomic::{self, AtomicBool}, - }, - time::Duration, - u32, -}; - use anyhow::Context as _; use collections::{BTreeSet, HashMap, HashSet, hash_map}; use db::kvp::KEY_VALUE_STORE; @@ -36,8 +22,21 @@ use gpui::{ uniform_list, }; use itertools::Itertools; -use language::{BufferId, BufferSnapshot, OffsetRangeExt, OutlineItem}; +use language::{Anchor, BufferId, BufferSnapshot, OffsetRangeExt, OutlineItem}; use menu::{Cancel, SelectFirst, SelectLast, SelectNext, SelectPrevious}; +use std::{ + cmp, + collections::BTreeMap, + hash::Hash, + ops::Range, + path::{MAIN_SEPARATOR_STR, Path, PathBuf}, + sync::{ + Arc, OnceLock, + atomic::{self, AtomicBool}, + }, + time::Duration, + u32, +}; use outline_panel_settings::{OutlinePanelDockPosition, OutlinePanelSettings, ShowIndentGuides}; use project::{File, Fs, GitEntry, GitTraversal, Project, ProjectItem}; @@ -132,6 +131,8 @@ pub struct OutlinePanel { hide_scrollbar_task: Option>, max_width_item_index: Option, preserve_selection_on_buffer_fold_toggles: HashSet, + pending_default_expansion_depth: Option, + outline_children_cache: HashMap, usize), bool>>, } #[derive(Debug)] @@ -318,12 +319,13 @@ struct CachedEntry { entry: PanelEntry, } -#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] +#[derive(Clone, Debug, PartialEq, Eq, Hash)] enum CollapsedEntry { Dir(WorktreeId, ProjectEntryId), File(WorktreeId, BufferId), ExternalFile(BufferId), Excerpt(BufferId, ExcerptId), + Outline(BufferId, ExcerptId, Range), } #[derive(Debug)] @@ -803,8 +805,56 @@ impl OutlinePanel { outline_panel.update_cached_entries(Some(UPDATE_DEBOUNCE), window, cx); } } else if &outline_panel_settings != new_settings { + let old_expansion_depth = outline_panel_settings.expand_outlines_with_depth; outline_panel_settings = *new_settings; - cx.notify(); + + if old_expansion_depth != new_settings.expand_outlines_with_depth { + let old_collapsed_entries = outline_panel.collapsed_entries.clone(); + outline_panel + .collapsed_entries + .retain(|entry| !matches!(entry, CollapsedEntry::Outline(..))); + + let new_depth = new_settings.expand_outlines_with_depth; + + for (buffer_id, excerpts) in &outline_panel.excerpts { + for (excerpt_id, excerpt) in excerpts { + if let ExcerptOutlines::Outlines(outlines) = &excerpt.outlines { + for outline in outlines { + if outline_panel + .outline_children_cache + .get(buffer_id) + .and_then(|children_map| { + let key = + (outline.range.clone(), outline.depth); + children_map.get(&key) + }) + .copied() + .unwrap_or(false) + && (new_depth == 0 || outline.depth >= new_depth) + { + outline_panel.collapsed_entries.insert( + CollapsedEntry::Outline( + *buffer_id, + *excerpt_id, + outline.range.clone(), + ), + ); + } + } + } + } + } + + if old_collapsed_entries != outline_panel.collapsed_entries { + outline_panel.update_cached_entries( + Some(UPDATE_DEBOUNCE), + window, + cx, + ); + } + } else { + cx.notify(); + } } }); @@ -841,6 +891,7 @@ impl OutlinePanel { updating_cached_entries: false, new_entries_for_fs_update: HashSet::default(), preserve_selection_on_buffer_fold_toggles: HashSet::default(), + pending_default_expansion_depth: None, fs_entries_update_task: Task::ready(()), cached_entries_update_task: Task::ready(()), reveal_selection_task: Task::ready(Ok(())), @@ -855,6 +906,7 @@ impl OutlinePanel { workspace_subscription, filter_update_subscription, ], + outline_children_cache: HashMap::default(), }; if let Some((item, editor)) = workspace_active_editor(workspace, cx) { outline_panel.replace_active_editor(item, editor, window, cx); @@ -1462,7 +1514,12 @@ impl OutlinePanel { PanelEntry::Outline(OutlineEntry::Excerpt(excerpt)) => { Some(CollapsedEntry::Excerpt(excerpt.buffer_id, excerpt.id)) } - PanelEntry::Search(_) | PanelEntry::Outline(..) => return, + PanelEntry::Outline(OutlineEntry::Outline(outline)) => Some(CollapsedEntry::Outline( + outline.buffer_id, + outline.excerpt_id, + outline.outline.range.clone(), + )), + PanelEntry::Search(_) => return, }; let Some(collapsed_entry) = entry_to_expand else { return; @@ -1565,7 +1622,14 @@ impl OutlinePanel { PanelEntry::Outline(OutlineEntry::Excerpt(excerpt)) => self .collapsed_entries .insert(CollapsedEntry::Excerpt(excerpt.buffer_id, excerpt.id)), - PanelEntry::Search(_) | PanelEntry::Outline(..) => false, + PanelEntry::Outline(OutlineEntry::Outline(outline)) => { + self.collapsed_entries.insert(CollapsedEntry::Outline( + outline.buffer_id, + outline.excerpt_id, + outline.outline.range.clone(), + )) + } + PanelEntry::Search(_) => false, }; if collapsed { @@ -1780,7 +1844,17 @@ impl OutlinePanel { self.collapsed_entries.insert(collapsed_entry); } } - PanelEntry::Search(_) | PanelEntry::Outline(..) => return, + PanelEntry::Outline(OutlineEntry::Outline(outline)) => { + let collapsed_entry = CollapsedEntry::Outline( + outline.buffer_id, + outline.excerpt_id, + outline.outline.range.clone(), + ); + if !self.collapsed_entries.remove(&collapsed_entry) { + self.collapsed_entries.insert(collapsed_entry); + } + } + _ => {} } active_editor.update(cx, |editor, cx| { @@ -2108,7 +2182,7 @@ impl OutlinePanel { PanelEntry::Outline(OutlineEntry::Excerpt(excerpt.clone())), item_id, depth, - Some(icon), + icon, is_active, label_element, window, @@ -2160,10 +2234,31 @@ impl OutlinePanel { _ => false, }; - let icon = if self.is_singleton_active(cx) { - None + let has_children = self + .outline_children_cache + .get(&outline.buffer_id) + .and_then(|children_map| { + let key = (outline.outline.range.clone(), outline.outline.depth); + children_map.get(&key) + }) + .copied() + .unwrap_or(false); + let is_expanded = !self.collapsed_entries.contains(&CollapsedEntry::Outline( + outline.buffer_id, + outline.excerpt_id, + outline.outline.range.clone(), + )); + + let icon = if has_children { + FileIcons::get_chevron_icon(is_expanded, cx) + .map(|icon_path| { + Icon::from_path(icon_path) + .color(entry_label_color(is_active)) + .into_any_element() + }) + .unwrap_or_else(empty_icon) } else { - Some(empty_icon()) + empty_icon() }; self.entry_element( @@ -2287,7 +2382,7 @@ impl OutlinePanel { PanelEntry::Fs(rendered_entry.clone()), item_id, depth, - Some(icon), + icon, is_active, label_element, window, @@ -2358,7 +2453,7 @@ impl OutlinePanel { PanelEntry::FoldedDirs(folded_dir.clone()), item_id, depth, - Some(icon), + icon, is_active, label_element, window, @@ -2449,7 +2544,7 @@ impl OutlinePanel { }), ElementId::from(SharedString::from(format!("search-{match_range:?}"))), depth, - None, + empty_icon(), is_active, entire_label, window, @@ -2462,7 +2557,7 @@ impl OutlinePanel { rendered_entry: PanelEntry, item_id: ElementId, depth: usize, - icon_element: Option, + icon_element: AnyElement, is_active: bool, label_element: gpui::AnyElement, window: &mut Window, @@ -2478,8 +2573,10 @@ impl OutlinePanel { if event.down.button == MouseButton::Right || event.down.first_mouse { return; } + let change_focus = event.down.click_count > 1; outline_panel.toggle_expanded(&clicked_entry, window, cx); + outline_panel.scroll_editor_to_entry( &clicked_entry, true, @@ -2495,10 +2592,11 @@ impl OutlinePanel { .indent_level(depth) .indent_step_size(px(settings.indent_size)) .toggle_state(is_active) - .when_some(icon_element, |list_item, icon_element| { - list_item.child(h_flex().child(icon_element)) - }) - .child(h_flex().h_6().child(label_element).ml_1()) + .child( + h_flex() + .child(h_flex().w(px(16.)).justify_center().child(icon_element)) + .child(h_flex().h_6().child(label_element).ml_1()), + ) .on_secondary_mouse_down(cx.listener( move |outline_panel, event: &MouseDownEvent, window, cx| { // Stop propagation to prevent the catch-all context menu for the project @@ -2940,7 +3038,12 @@ impl OutlinePanel { outline_panel.fs_entries_depth = new_depth_map; outline_panel.fs_children_count = new_children_count; outline_panel.update_non_fs_items(window, cx); - outline_panel.update_cached_entries(debounce, window, cx); + + // Only update cached entries if we don't have outlines to fetch + // If we do have outlines to fetch, let fetch_outdated_outlines handle the update + if outline_panel.excerpt_fetch_ranges(cx).is_empty() { + outline_panel.update_cached_entries(debounce, window, cx); + } cx.notify(); }) @@ -2956,6 +3059,12 @@ impl OutlinePanel { cx: &mut Context, ) { self.clear_previous(window, cx); + + let default_expansion_depth = + OutlinePanelSettings::get_global(cx).expand_outlines_with_depth; + // We'll apply the expansion depth after outlines are loaded + self.pending_default_expansion_depth = Some(default_expansion_depth); + let buffer_search_subscription = cx.subscribe_in( &new_active_editor, window, @@ -3004,6 +3113,7 @@ impl OutlinePanel { self.selected_entry = SelectedEntry::None; self.pinned = false; self.mode = ItemsDisplayMode::Outline; + self.pending_default_expansion_depth = None; } fn location_for_editor_selection( @@ -3259,25 +3369,74 @@ impl OutlinePanel { || buffer_language.as_ref() == buffer_snapshot.language_at(outline.range.start) }); - outlines + + let outlines_with_children = outlines + .windows(2) + .filter_map(|window| { + let current = &window[0]; + let next = &window[1]; + if next.depth > current.depth { + Some((current.range.clone(), current.depth)) + } else { + None + } + }) + .collect::>(); + + (outlines, outlines_with_children) }) .await; + + let (fetched_outlines, outlines_with_children) = fetched_outlines; + outline_panel .update_in(cx, |outline_panel, window, cx| { + let pending_default_depth = + outline_panel.pending_default_expansion_depth.take(); + + let debounce = + if first_update.fetch_and(false, atomic::Ordering::AcqRel) { + None + } else { + Some(UPDATE_DEBOUNCE) + }; + if let Some(excerpt) = outline_panel .excerpts .entry(buffer_id) .or_default() .get_mut(&excerpt_id) { - let debounce = if first_update - .fetch_and(false, atomic::Ordering::AcqRel) - { - None - } else { - Some(UPDATE_DEBOUNCE) - }; excerpt.outlines = ExcerptOutlines::Outlines(fetched_outlines); + + if let Some(default_depth) = pending_default_depth { + if let ExcerptOutlines::Outlines(outlines) = + &excerpt.outlines + { + outlines + .iter() + .filter(|outline| { + (default_depth == 0 + || outline.depth >= default_depth) + && outlines_with_children.contains(&( + outline.range.clone(), + outline.depth, + )) + }) + .for_each(|outline| { + outline_panel.collapsed_entries.insert( + CollapsedEntry::Outline( + buffer_id, + excerpt_id, + outline.range.clone(), + ), + ); + }); + } + } + + // Even if no outlines to check, we still need to update cached entries + // to show the outline entries that were just fetched outline_panel.update_cached_entries(debounce, window, cx); } }) @@ -4083,7 +4242,7 @@ impl OutlinePanel { } fn add_excerpt_entries( - &self, + &mut self, state: &mut GenerationState, buffer_id: BufferId, entries_to_add: &[ExcerptId], @@ -4094,6 +4253,8 @@ impl OutlinePanel { cx: &mut Context, ) { if let Some(excerpts) = self.excerpts.get(&buffer_id) { + let buffer_snapshot = self.buffer_snapshot_for_id(buffer_id, cx); + for &excerpt_id in entries_to_add { let Some(excerpt) = excerpts.get(&excerpt_id) else { continue; @@ -4123,15 +4284,84 @@ impl OutlinePanel { continue; } - for outline in excerpt.iter_outlines() { + let mut last_depth_at_level: Vec>> = vec![None; 10]; + + let all_outlines: Vec<_> = excerpt.iter_outlines().collect(); + + let mut outline_has_children = HashMap::default(); + let mut visible_outlines = Vec::new(); + let mut collapsed_state: Option<(usize, Range)> = None; + + for (i, &outline) in all_outlines.iter().enumerate() { + let has_children = all_outlines + .get(i + 1) + .map(|next| next.depth > outline.depth) + .unwrap_or(false); + + outline_has_children + .insert((outline.range.clone(), outline.depth), has_children); + + let mut should_include = true; + + if let Some((collapsed_depth, collapsed_range)) = &collapsed_state { + if outline.depth <= *collapsed_depth { + collapsed_state = None; + } else if let Some(buffer_snapshot) = buffer_snapshot.as_ref() { + let outline_start = outline.range.start; + if outline_start + .cmp(&collapsed_range.start, buffer_snapshot) + .is_ge() + && outline_start + .cmp(&collapsed_range.end, buffer_snapshot) + .is_lt() + { + should_include = false; // Skip - inside collapsed range + } else { + collapsed_state = None; + } + } + } + + // Check if this outline itself is collapsed + if should_include + && self.collapsed_entries.contains(&CollapsedEntry::Outline( + buffer_id, + excerpt_id, + outline.range.clone(), + )) + { + collapsed_state = Some((outline.depth, outline.range.clone())); + } + + if should_include { + visible_outlines.push(outline); + } + } + + self.outline_children_cache + .entry(buffer_id) + .or_default() + .extend(outline_has_children); + + for outline in visible_outlines { + let outline_entry = OutlineEntryOutline { + buffer_id, + excerpt_id, + outline: outline.clone(), + }; + + if outline.depth < last_depth_at_level.len() { + last_depth_at_level[outline.depth] = Some(outline.range.clone()); + // Clear deeper levels when we go back to a shallower depth + for d in (outline.depth + 1)..last_depth_at_level.len() { + last_depth_at_level[d] = None; + } + } + self.push_entry( state, track_matches, - PanelEntry::Outline(OutlineEntry::Outline(OutlineEntryOutline { - buffer_id, - excerpt_id, - outline: outline.clone(), - })), + PanelEntry::Outline(OutlineEntry::Outline(outline_entry)), outline_base_depth + outline.depth, cx, ); @@ -6908,4 +7138,540 @@ outline: struct OutlineEntryExcerpt multi_buffer_snapshot.text_for_range(line_start..line_end).collect::().trim().to_owned() }) } + + #[gpui::test] + async fn test_outline_keyboard_expand_collapse(cx: &mut TestAppContext) { + init_test(cx); + + let fs = FakeFs::new(cx.background_executor.clone()); + fs.insert_tree( + "/test", + json!({ + "src": { + "lib.rs": indoc!(" + mod outer { + pub struct OuterStruct { + field: String, + } + impl OuterStruct { + pub fn new() -> Self { + Self { field: String::new() } + } + pub fn method(&self) { + println!(\"{}\", self.field); + } + } + mod inner { + pub fn inner_function() { + let x = 42; + println!(\"{}\", x); + } + pub struct InnerStruct { + value: i32, + } + } + } + fn main() { + let s = outer::OuterStruct::new(); + s.method(); + } + "), + } + }), + ) + .await; + + let project = Project::test(fs.clone(), ["/test".as_ref()], cx).await; + project.read_with(cx, |project, _| { + project.languages().add(Arc::new( + rust_lang() + .with_outline_query( + r#" + (struct_item + (visibility_modifier)? @context + "struct" @context + name: (_) @name) @item + (impl_item + "impl" @context + trait: (_)? @context + "for"? @context + type: (_) @context + body: (_)) @item + (function_item + (visibility_modifier)? @context + "fn" @context + name: (_) @name + parameters: (_) @context) @item + (mod_item + (visibility_modifier)? @context + "mod" @context + name: (_) @name) @item + (enum_item + (visibility_modifier)? @context + "enum" @context + name: (_) @name) @item + (field_declaration + (visibility_modifier)? @context + name: (_) @name + ":" @context + type: (_) @context) @item + "#, + ) + .unwrap(), + )) + }); + let workspace = add_outline_panel(&project, cx).await; + let cx = &mut VisualTestContext::from_window(*workspace, cx); + let outline_panel = outline_panel(&workspace, cx); + + outline_panel.update_in(cx, |outline_panel, window, cx| { + outline_panel.set_active(true, window, cx) + }); + + workspace + .update(cx, |workspace, window, cx| { + workspace.open_abs_path( + PathBuf::from("/test/src/lib.rs"), + OpenOptions { + visible: Some(OpenVisible::All), + ..Default::default() + }, + window, + cx, + ) + }) + .unwrap() + .await + .unwrap(); + + cx.executor() + .advance_clock(UPDATE_DEBOUNCE + Duration::from_millis(500)); + cx.run_until_parked(); + + // Force another update cycle to ensure outlines are fetched + outline_panel.update_in(cx, |panel, window, cx| { + panel.update_non_fs_items(window, cx); + panel.update_cached_entries(Some(UPDATE_DEBOUNCE), window, cx); + }); + cx.executor() + .advance_clock(UPDATE_DEBOUNCE + Duration::from_millis(500)); + cx.run_until_parked(); + + outline_panel.update(cx, |outline_panel, cx| { + assert_eq!( + display_entries( + &project, + &snapshot(&outline_panel, cx), + &outline_panel.cached_entries, + outline_panel.selected_entry(), + cx, + ), + indoc!( + " +outline: mod outer <==== selected + outline: pub struct OuterStruct + outline: field: String + outline: impl OuterStruct + outline: pub fn new() + outline: pub fn method(&self) + outline: mod inner + outline: pub fn inner_function() + outline: pub struct InnerStruct + outline: value: i32 +outline: fn main()" + ) + ); + }); + + let parent_outline = outline_panel + .read_with(cx, |panel, _cx| { + panel + .cached_entries + .iter() + .find_map(|entry| match &entry.entry { + PanelEntry::Outline(OutlineEntry::Outline(outline)) + if panel + .outline_children_cache + .get(&outline.buffer_id) + .and_then(|children_map| { + let key = + (outline.outline.range.clone(), outline.outline.depth); + children_map.get(&key) + }) + .copied() + .unwrap_or(false) => + { + Some(entry.entry.clone()) + } + _ => None, + }) + }) + .expect("Should find an outline with children"); + + outline_panel.update_in(cx, |panel, window, cx| { + panel.select_entry(parent_outline.clone(), true, window, cx); + panel.collapse_selected_entry(&CollapseSelectedEntry, window, cx); + }); + cx.executor() + .advance_clock(UPDATE_DEBOUNCE + Duration::from_millis(100)); + cx.run_until_parked(); + + outline_panel.update(cx, |outline_panel, cx| { + assert_eq!( + display_entries( + &project, + &snapshot(&outline_panel, cx), + &outline_panel.cached_entries, + outline_panel.selected_entry(), + cx, + ), + indoc!( + " +outline: mod outer <==== selected +outline: fn main()" + ) + ); + }); + + outline_panel.update_in(cx, |panel, window, cx| { + panel.expand_selected_entry(&ExpandSelectedEntry, window, cx); + }); + cx.executor() + .advance_clock(UPDATE_DEBOUNCE + Duration::from_millis(100)); + cx.run_until_parked(); + + outline_panel.update(cx, |outline_panel, cx| { + assert_eq!( + display_entries( + &project, + &snapshot(&outline_panel, cx), + &outline_panel.cached_entries, + outline_panel.selected_entry(), + cx, + ), + indoc!( + " +outline: mod outer <==== selected + outline: pub struct OuterStruct + outline: field: String + outline: impl OuterStruct + outline: pub fn new() + outline: pub fn method(&self) + outline: mod inner + outline: pub fn inner_function() + outline: pub struct InnerStruct + outline: value: i32 +outline: fn main()" + ) + ); + }); + + outline_panel.update_in(cx, |panel, window, cx| { + panel.collapsed_entries.clear(); + panel.update_cached_entries(None, window, cx); + }); + cx.executor() + .advance_clock(UPDATE_DEBOUNCE + Duration::from_millis(100)); + cx.run_until_parked(); + + outline_panel.update_in(cx, |panel, window, cx| { + let outlines_with_children: Vec<_> = panel + .cached_entries + .iter() + .filter_map(|entry| match &entry.entry { + PanelEntry::Outline(OutlineEntry::Outline(outline)) + if panel + .outline_children_cache + .get(&outline.buffer_id) + .and_then(|children_map| { + let key = (outline.outline.range.clone(), outline.outline.depth); + children_map.get(&key) + }) + .copied() + .unwrap_or(false) => + { + Some(entry.entry.clone()) + } + _ => None, + }) + .collect(); + + for outline in outlines_with_children { + panel.select_entry(outline, false, window, cx); + panel.collapse_selected_entry(&CollapseSelectedEntry, window, cx); + } + }); + cx.executor() + .advance_clock(UPDATE_DEBOUNCE + Duration::from_millis(100)); + cx.run_until_parked(); + + outline_panel.update(cx, |outline_panel, cx| { + assert_eq!( + display_entries( + &project, + &snapshot(&outline_panel, cx), + &outline_panel.cached_entries, + outline_panel.selected_entry(), + cx, + ), + indoc!( + " +outline: mod outer +outline: fn main()" + ) + ); + }); + + let collapsed_entries_count = + outline_panel.read_with(cx, |panel, _| panel.collapsed_entries.len()); + assert!( + collapsed_entries_count > 0, + "Should have collapsed entries tracked" + ); + } + + #[gpui::test] + async fn test_outline_click_toggle_behavior(cx: &mut TestAppContext) { + init_test(cx); + + let fs = FakeFs::new(cx.background_executor.clone()); + fs.insert_tree( + "/test", + json!({ + "src": { + "main.rs": indoc!(" + struct Config { + name: String, + value: i32, + } + impl Config { + fn new(name: String) -> Self { + Self { name, value: 0 } + } + fn get_value(&self) -> i32 { + self.value + } + } + enum Status { + Active, + Inactive, + } + fn process_config(config: Config) -> Status { + if config.get_value() > 0 { + Status::Active + } else { + Status::Inactive + } + } + fn main() { + let config = Config::new(\"test\".to_string()); + let status = process_config(config); + } + "), + } + }), + ) + .await; + + let project = Project::test(fs.clone(), ["/test".as_ref()], cx).await; + project.read_with(cx, |project, _| { + project.languages().add(Arc::new( + rust_lang() + .with_outline_query( + r#" + (struct_item + (visibility_modifier)? @context + "struct" @context + name: (_) @name) @item + (impl_item + "impl" @context + trait: (_)? @context + "for"? @context + type: (_) @context + body: (_)) @item + (function_item + (visibility_modifier)? @context + "fn" @context + name: (_) @name + parameters: (_) @context) @item + (mod_item + (visibility_modifier)? @context + "mod" @context + name: (_) @name) @item + (enum_item + (visibility_modifier)? @context + "enum" @context + name: (_) @name) @item + (field_declaration + (visibility_modifier)? @context + name: (_) @name + ":" @context + type: (_) @context) @item + "#, + ) + .unwrap(), + )) + }); + + let workspace = add_outline_panel(&project, cx).await; + let cx = &mut VisualTestContext::from_window(*workspace, cx); + let outline_panel = outline_panel(&workspace, cx); + + outline_panel.update_in(cx, |outline_panel, window, cx| { + outline_panel.set_active(true, window, cx) + }); + + let _editor = workspace + .update(cx, |workspace, window, cx| { + workspace.open_abs_path( + PathBuf::from("/test/src/main.rs"), + OpenOptions { + visible: Some(OpenVisible::All), + ..Default::default() + }, + window, + cx, + ) + }) + .unwrap() + .await + .unwrap(); + + cx.executor() + .advance_clock(UPDATE_DEBOUNCE + Duration::from_millis(100)); + cx.run_until_parked(); + + outline_panel.update(cx, |outline_panel, _cx| { + outline_panel.selected_entry = SelectedEntry::None; + }); + + // Check initial state - all entries should be expanded by default + outline_panel.update(cx, |outline_panel, cx| { + assert_eq!( + display_entries( + &project, + &snapshot(&outline_panel, cx), + &outline_panel.cached_entries, + outline_panel.selected_entry(), + cx, + ), + indoc!( + " +outline: struct Config + outline: name: String + outline: value: i32 +outline: impl Config + outline: fn new(name: String) + outline: fn get_value(&self) +outline: enum Status +outline: fn process_config(config: Config) +outline: fn main()" + ) + ); + }); + + outline_panel.update(cx, |outline_panel, _cx| { + outline_panel.selected_entry = SelectedEntry::None; + }); + + cx.update(|window, cx| { + outline_panel.update(cx, |outline_panel, cx| { + outline_panel.select_first(&SelectFirst, window, cx); + }); + }); + + cx.executor() + .advance_clock(UPDATE_DEBOUNCE + Duration::from_millis(100)); + cx.run_until_parked(); + + outline_panel.update(cx, |outline_panel, cx| { + assert_eq!( + display_entries( + &project, + &snapshot(&outline_panel, cx), + &outline_panel.cached_entries, + outline_panel.selected_entry(), + cx, + ), + indoc!( + " +outline: struct Config <==== selected + outline: name: String + outline: value: i32 +outline: impl Config + outline: fn new(name: String) + outline: fn get_value(&self) +outline: enum Status +outline: fn process_config(config: Config) +outline: fn main()" + ) + ); + }); + + cx.update(|window, cx| { + outline_panel.update(cx, |outline_panel, cx| { + outline_panel.open_selected_entry(&OpenSelectedEntry, window, cx); + }); + }); + + cx.executor() + .advance_clock(UPDATE_DEBOUNCE + Duration::from_millis(100)); + cx.run_until_parked(); + + outline_panel.update(cx, |outline_panel, cx| { + assert_eq!( + display_entries( + &project, + &snapshot(&outline_panel, cx), + &outline_panel.cached_entries, + outline_panel.selected_entry(), + cx, + ), + indoc!( + " +outline: struct Config <==== selected +outline: impl Config + outline: fn new(name: String) + outline: fn get_value(&self) +outline: enum Status +outline: fn process_config(config: Config) +outline: fn main()" + ) + ); + }); + + cx.update(|window, cx| { + outline_panel.update(cx, |outline_panel, cx| { + outline_panel.open_selected_entry(&OpenSelectedEntry, window, cx); + }); + }); + + cx.executor() + .advance_clock(UPDATE_DEBOUNCE + Duration::from_millis(100)); + cx.run_until_parked(); + + outline_panel.update(cx, |outline_panel, cx| { + assert_eq!( + display_entries( + &project, + &snapshot(&outline_panel, cx), + &outline_panel.cached_entries, + outline_panel.selected_entry(), + cx, + ), + indoc!( + " +outline: struct Config <==== selected + outline: name: String + outline: value: i32 +outline: impl Config + outline: fn new(name: String) + outline: fn get_value(&self) +outline: enum Status +outline: fn process_config(config: Config) +outline: fn main()" + ) + ); + }); + } } diff --git a/crates/outline_panel/src/outline_panel_settings.rs b/crates/outline_panel/src/outline_panel_settings.rs index 6b70cb54fb..133d28b748 100644 --- a/crates/outline_panel/src/outline_panel_settings.rs +++ b/crates/outline_panel/src/outline_panel_settings.rs @@ -31,6 +31,7 @@ pub struct OutlinePanelSettings { pub auto_reveal_entries: bool, pub auto_fold_dirs: bool, pub scrollbar: ScrollbarSettings, + pub expand_outlines_with_depth: usize, } #[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq, Eq)] @@ -105,6 +106,13 @@ pub struct OutlinePanelSettingsContent { pub indent_guides: Option, /// Scrollbar-related settings pub scrollbar: Option, + /// Default depth to expand outline items in the current file. + /// The default depth to which outline entries are expanded on reveal. + /// - Set to 0 to collapse all items that have children + /// - Set to 1 or higher to collapse items at that depth or deeper + /// + /// Default: 100 + pub expand_outlines_with_depth: Option, } impl Settings for OutlinePanelSettings { From 50985b7d2306988c03f87a78e89376dc44f7faac Mon Sep 17 00:00:00 2001 From: "Joseph T. Lyons" Date: Wed, 23 Jul 2025 16:30:21 -0400 Subject: [PATCH 005/893] Fix telemetry event type names (#34974) Release Notes: - N/A --- crates/ai_onboarding/src/ai_onboarding.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/crates/ai_onboarding/src/ai_onboarding.rs b/crates/ai_onboarding/src/ai_onboarding.rs index 9d32b1ee09..f9a91503ae 100644 --- a/crates/ai_onboarding/src/ai_onboarding.rs +++ b/crates/ai_onboarding/src/ai_onboarding.rs @@ -237,7 +237,7 @@ impl ZedAiOnboarding { .icon_color(Color::Muted) .icon_size(IconSize::XSmall) .on_click(move |_, _window, cx| { - telemetry::event!("Review Terms of Service Click"); + telemetry::event!("Review Terms of Service Clicked"); cx.open_url(&zed_urls::terms_of_service(cx)) }), ) @@ -248,7 +248,7 @@ impl ZedAiOnboarding { .on_click({ let callback = self.accept_terms_of_service.clone(); move |_, window, cx| { - telemetry::event!("Accepted Terms of Service"); + telemetry::event!("Terms of Service Accepted"); (callback)(window, cx)} }), ) From edceb7284f895539fdd71533c1e59c31c4b7940e Mon Sep 17 00:00:00 2001 From: Peter Tripp Date: Wed, 23 Jul 2025 16:55:13 -0400 Subject: [PATCH 006/893] Redact secrets from environment in LSP Server Info (#34971) In "Server Info" view of LSP logs: - Redacts sensitive values from environment - Sorts environment by name | Before | After | | - | - | | Screenshot 2025-07-23 at 14 10 14 | image | Release Notes: - Improved display of environment variables in LSP Logs: Server Info view --- crates/lsp/src/lsp.rs | 33 ++++++++++++++++++++++++++++++--- 1 file changed, 30 insertions(+), 3 deletions(-) diff --git a/crates/lsp/src/lsp.rs b/crates/lsp/src/lsp.rs index 7dcfa61f47..a820aaf748 100644 --- a/crates/lsp/src/lsp.rs +++ b/crates/lsp/src/lsp.rs @@ -4,7 +4,7 @@ pub use lsp_types::request::*; pub use lsp_types::*; use anyhow::{Context as _, Result, anyhow}; -use collections::HashMap; +use collections::{BTreeMap, HashMap}; use futures::{ AsyncRead, AsyncWrite, Future, FutureExt, channel::oneshot::{self, Canceled}, @@ -40,7 +40,7 @@ use std::{ time::{Duration, Instant}, }; use std::{path::Path, process::Stdio}; -use util::{ConnectionResult, ResultExt, TryFutureExt}; +use util::{ConnectionResult, ResultExt, TryFutureExt, redact}; const JSON_RPC_VERSION: &str = "2.0"; const CONTENT_LEN_HEADER: &str = "Content-Length: "; @@ -62,7 +62,7 @@ pub enum IoKind { /// Represents a launchable language server. This can either be a standalone binary or the path /// to a runtime with arguments to instruct it to launch the actual language server file. -#[derive(Debug, Clone, Deserialize)] +#[derive(Clone, Deserialize)] pub struct LanguageServerBinary { pub path: PathBuf, pub arguments: Vec, @@ -1448,6 +1448,33 @@ impl fmt::Debug for LanguageServer { } } +impl fmt::Debug for LanguageServerBinary { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + let mut debug = f.debug_struct("LanguageServerBinary"); + debug.field("path", &self.path); + debug.field("arguments", &self.arguments); + + if let Some(env) = &self.env { + let redacted_env: BTreeMap = env + .iter() + .map(|(key, value)| { + let redacted_value = if redact::should_redact(key) { + "REDACTED".to_string() + } else { + value.clone() + }; + (key.clone(), redacted_value) + }) + .collect(); + debug.field("env", &Some(redacted_env)); + } else { + debug.field("env", &self.env); + } + + debug.finish() + } +} + impl Drop for Subscription { fn drop(&mut self) { match self { From 8bf7dcb6131e6d40c59c03a0ddd6c53aacbe7516 Mon Sep 17 00:00:00 2001 From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com> Date: Wed, 23 Jul 2025 18:09:05 -0300 Subject: [PATCH 007/893] agent: Fix follow button disabled state (#34978) Release Notes: - N/A --- crates/agent_ui/src/message_editor.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/agent_ui/src/message_editor.rs b/crates/agent_ui/src/message_editor.rs index ab8ba762f4..62be5629f1 100644 --- a/crates/agent_ui/src/message_editor.rs +++ b/crates/agent_ui/src/message_editor.rs @@ -625,7 +625,7 @@ impl MessageEditor { .unwrap_or(false); IconButton::new("follow-agent", IconName::Crosshair) - .disabled(is_model_selected) + .disabled(!is_model_selected) .icon_size(IconSize::Small) .icon_color(Color::Muted) .toggle_state(following) From 7e9d6cc25c1829089918d514b85f3a419ca26dc7 Mon Sep 17 00:00:00 2001 From: Renato Lochetti Date: Wed, 23 Jul 2025 22:27:25 +0100 Subject: [PATCH 008/893] mistral: Add support for Mistral Devstral Medium (#34888) Mistral released their new DevstralMedium model to be used via API: https://mistral.ai/news/devstral-2507 Release Notes: - Add support for Mistral Devstral Medium --- crates/mistral/src/mistral.rs | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/crates/mistral/src/mistral.rs b/crates/mistral/src/mistral.rs index a3a017be83..bf6ccf2883 100644 --- a/crates/mistral/src/mistral.rs +++ b/crates/mistral/src/mistral.rs @@ -58,6 +58,8 @@ pub enum Model { OpenMistralNemo, #[serde(rename = "open-codestral-mamba", alias = "open-codestral-mamba")] OpenCodestralMamba, + #[serde(rename = "devstral-medium-latest", alias = "devstral-medium-latest")] + DevstralMediumLatest, #[serde(rename = "devstral-small-latest", alias = "devstral-small-latest")] DevstralSmallLatest, #[serde(rename = "pixtral-12b-latest", alias = "pixtral-12b-latest")] @@ -91,6 +93,7 @@ impl Model { "mistral-small-latest" => Ok(Self::MistralSmallLatest), "open-mistral-nemo" => Ok(Self::OpenMistralNemo), "open-codestral-mamba" => Ok(Self::OpenCodestralMamba), + "devstral-medium-latest" => Ok(Self::DevstralMediumLatest), "devstral-small-latest" => Ok(Self::DevstralSmallLatest), "pixtral-12b-latest" => Ok(Self::Pixtral12BLatest), "pixtral-large-latest" => Ok(Self::PixtralLargeLatest), @@ -106,6 +109,7 @@ impl Model { Self::MistralSmallLatest => "mistral-small-latest", Self::OpenMistralNemo => "open-mistral-nemo", Self::OpenCodestralMamba => "open-codestral-mamba", + Self::DevstralMediumLatest => "devstral-medium-latest", Self::DevstralSmallLatest => "devstral-small-latest", Self::Pixtral12BLatest => "pixtral-12b-latest", Self::PixtralLargeLatest => "pixtral-large-latest", @@ -121,6 +125,7 @@ impl Model { Self::MistralSmallLatest => "mistral-small-latest", Self::OpenMistralNemo => "open-mistral-nemo", Self::OpenCodestralMamba => "open-codestral-mamba", + Self::DevstralMediumLatest => "devstral-medium-latest", Self::DevstralSmallLatest => "devstral-small-latest", Self::Pixtral12BLatest => "pixtral-12b-latest", Self::PixtralLargeLatest => "pixtral-large-latest", @@ -138,6 +143,7 @@ impl Model { Self::MistralSmallLatest => 32000, Self::OpenMistralNemo => 131000, Self::OpenCodestralMamba => 256000, + Self::DevstralMediumLatest => 128000, Self::DevstralSmallLatest => 262144, Self::Pixtral12BLatest => 128000, Self::PixtralLargeLatest => 128000, @@ -162,6 +168,7 @@ impl Model { | Self::MistralSmallLatest | Self::OpenMistralNemo | Self::OpenCodestralMamba + | Self::DevstralMediumLatest | Self::DevstralSmallLatest | Self::Pixtral12BLatest | Self::PixtralLargeLatest => true, @@ -179,6 +186,7 @@ impl Model { | Self::MistralLargeLatest | Self::OpenMistralNemo | Self::OpenCodestralMamba + | Self::DevstralMediumLatest | Self::DevstralSmallLatest => false, Self::Custom { supports_images, .. From b63d820be23762f10313bce17e9c98cbba7ab9dd Mon Sep 17 00:00:00 2001 From: Smit Barmase Date: Thu, 24 Jul 2025 03:46:29 +0530 Subject: [PATCH 009/893] editor: Fix move line up panic when selection is at end of line next to fold marker (#34982) Closes #34826 In move line up method, make use of `prev_line_boundary` which accounts for fold map, etc., for selection start row so that we don't incorrectly calculate row range to move up. Release Notes: - Fixed an issue where `editor: move line up` action sometimes crashed if the cursor was at the end of a line beside a fold marker. --- crates/editor/src/editor.rs | 10 +++++++++- crates/editor/src/editor_tests.rs | 27 +++++++++++++++++++++++++++ 2 files changed, 36 insertions(+), 1 deletion(-) diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs index d5448f30f3..a695c8fd0c 100644 --- a/crates/editor/src/editor.rs +++ b/crates/editor/src/editor.rs @@ -22258,7 +22258,7 @@ fn consume_contiguous_rows( selections: &mut Peekable>>, ) -> (MultiBufferRow, MultiBufferRow) { contiguous_row_selections.push(selection.clone()); - let start_row = MultiBufferRow(selection.start.row); + let start_row = starting_row(selection, display_map); let mut end_row = ending_row(selection, display_map); while let Some(next_selection) = selections.peek() { @@ -22272,6 +22272,14 @@ fn consume_contiguous_rows( (start_row, end_row) } +fn starting_row(selection: &Selection, display_map: &DisplaySnapshot) -> MultiBufferRow { + if selection.start.column > 0 { + MultiBufferRow(display_map.prev_line_boundary(selection.start).0.row) + } else { + MultiBufferRow(selection.start.row) + } +} + fn ending_row(next_selection: &Selection, display_map: &DisplaySnapshot) -> MultiBufferRow { if next_selection.end.column > 0 || next_selection.is_empty() { MultiBufferRow(display_map.next_line_boundary(next_selection.end).0.row + 1) diff --git a/crates/editor/src/editor_tests.rs b/crates/editor/src/editor_tests.rs index b9ca8c3755..0d69c067ee 100644 --- a/crates/editor/src/editor_tests.rs +++ b/crates/editor/src/editor_tests.rs @@ -5069,6 +5069,33 @@ fn test_move_line_up_down(cx: &mut TestAppContext) { }); } +#[gpui::test] +fn test_move_line_up_selection_at_end_of_fold(cx: &mut TestAppContext) { + init_test(cx, |_| {}); + let editor = cx.add_window(|window, cx| { + let buffer = MultiBuffer::build_simple("\n\n\n\n\n\naaaa\nbbbb\ncccc", cx); + build_editor(buffer, window, cx) + }); + _ = editor.update(cx, |editor, window, cx| { + editor.fold_creases( + vec![Crease::simple( + Point::new(6, 4)..Point::new(7, 4), + FoldPlaceholder::test(), + )], + true, + window, + cx, + ); + editor.change_selections(SelectionEffects::no_scroll(), window, cx, |s| { + s.select_ranges([Point::new(7, 4)..Point::new(7, 4)]) + }); + assert_eq!(editor.display_text(cx), "\n\n\n\n\n\naaaa⋯\ncccc"); + editor.move_line_up(&MoveLineUp, window, cx); + let buffer_text = editor.buffer.read(cx).snapshot(cx).text(); + assert_eq!(buffer_text, "\n\n\n\n\naaaa\nbbbb\n\ncccc"); + }); +} + #[gpui::test] fn test_move_line_up_down_with_blocks(cx: &mut TestAppContext) { init_test(cx, |_| {}); From 3da23cc65bf8b900219b85002b5b38dca0d3b83e Mon Sep 17 00:00:00 2001 From: Piotr Osiewicz <24362066+osiewicz@users.noreply.github.com> Date: Thu, 24 Jul 2025 00:33:43 +0200 Subject: [PATCH 010/893] Re-land taffy 0.8.3 (#34939) Re #34938 - **chore: Bump taffy to 0.8.3** - **editor: Fix sticky multi-buffer header not extending to the full width** Release Notes: - N/A --- Cargo.lock | 9 ++++----- crates/editor/src/code_context_menus.rs | 2 +- crates/editor/src/element.rs | 1 + crates/gpui/Cargo.toml | 2 +- crates/gpui/src/taffy.rs | 26 ++++++++++++------------- 5 files changed, 20 insertions(+), 20 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 851c658735..8f791d395a 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -7402,9 +7402,9 @@ dependencies = [ [[package]] name = "grid" -version = "0.14.0" +version = "0.17.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "be136d9dacc2a13cc70bb6c8f902b414fb2641f8db1314637c6b7933411a8f82" +checksum = "71b01d27060ad58be4663b9e4ac9e2d4806918e8876af8912afbddd1a91d5eaa" [[package]] name = "group" @@ -15961,13 +15961,12 @@ dependencies = [ [[package]] name = "taffy" -version = "0.5.1" +version = "0.8.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e8b61630cba2afd2c851821add2e1bb1b7851a2436e839ab73b56558b009035e" +checksum = "7aaef0ac998e6527d6d0d5582f7e43953bb17221ac75bb8eb2fcc2db3396db1c" dependencies = [ "arrayvec", "grid", - "num-traits", "serde", "slotmap", ] diff --git a/crates/editor/src/code_context_menus.rs b/crates/editor/src/code_context_menus.rs index 9f842836ed..52446ceafc 100644 --- a/crates/editor/src/code_context_menus.rs +++ b/crates/editor/src/code_context_menus.rs @@ -844,7 +844,7 @@ impl CompletionsMenu { .with_sizing_behavior(ListSizingBehavior::Infer) .w(rems(34.)); - Popover::new().child(list).into_any_element() + Popover::new().child(div().child(list)).into_any_element() } fn render_aside( diff --git a/crates/editor/src/element.rs b/crates/editor/src/element.rs index 1b372a7d53..d2ee9d6b0a 100644 --- a/crates/editor/src/element.rs +++ b/crates/editor/src/element.rs @@ -4010,6 +4010,7 @@ impl EditorElement { let available_width = hitbox.bounds.size.width - right_margin; let mut header = v_flex() + .w_full() .relative() .child( div() diff --git a/crates/gpui/Cargo.toml b/crates/gpui/Cargo.toml index b446ea8bd8..29e81269e3 100644 --- a/crates/gpui/Cargo.toml +++ b/crates/gpui/Cargo.toml @@ -121,7 +121,7 @@ smallvec.workspace = true smol.workspace = true strum.workspace = true sum_tree.workspace = true -taffy = "=0.5.1" +taffy = "=0.8.3" thiserror.workspace = true util.workspace = true uuid.workspace = true diff --git a/crates/gpui/src/taffy.rs b/crates/gpui/src/taffy.rs index 6228a60490..f7fa54256d 100644 --- a/crates/gpui/src/taffy.rs +++ b/crates/gpui/src/taffy.rs @@ -283,7 +283,7 @@ impl ToTaffy for Length { fn to_taffy(&self, rem_size: Pixels) -> taffy::prelude::LengthPercentageAuto { match self { Length::Definite(length) => length.to_taffy(rem_size), - Length::Auto => taffy::prelude::LengthPercentageAuto::Auto, + Length::Auto => taffy::prelude::LengthPercentageAuto::auto(), } } } @@ -292,7 +292,7 @@ impl ToTaffy for Length { fn to_taffy(&self, rem_size: Pixels) -> taffy::prelude::Dimension { match self { Length::Definite(length) => length.to_taffy(rem_size), - Length::Auto => taffy::prelude::Dimension::Auto, + Length::Auto => taffy::prelude::Dimension::auto(), } } } @@ -302,14 +302,14 @@ impl ToTaffy for DefiniteLength { match self { DefiniteLength::Absolute(length) => match length { AbsoluteLength::Pixels(pixels) => { - taffy::style::LengthPercentage::Length(pixels.into()) + taffy::style::LengthPercentage::length(pixels.into()) } AbsoluteLength::Rems(rems) => { - taffy::style::LengthPercentage::Length((*rems * rem_size).into()) + taffy::style::LengthPercentage::length((*rems * rem_size).into()) } }, DefiniteLength::Fraction(fraction) => { - taffy::style::LengthPercentage::Percent(*fraction) + taffy::style::LengthPercentage::percent(*fraction) } } } @@ -320,14 +320,14 @@ impl ToTaffy for DefiniteLength { match self { DefiniteLength::Absolute(length) => match length { AbsoluteLength::Pixels(pixels) => { - taffy::style::LengthPercentageAuto::Length(pixels.into()) + taffy::style::LengthPercentageAuto::length(pixels.into()) } AbsoluteLength::Rems(rems) => { - taffy::style::LengthPercentageAuto::Length((*rems * rem_size).into()) + taffy::style::LengthPercentageAuto::length((*rems * rem_size).into()) } }, DefiniteLength::Fraction(fraction) => { - taffy::style::LengthPercentageAuto::Percent(*fraction) + taffy::style::LengthPercentageAuto::percent(*fraction) } } } @@ -337,12 +337,12 @@ impl ToTaffy for DefiniteLength { fn to_taffy(&self, rem_size: Pixels) -> taffy::style::Dimension { match self { DefiniteLength::Absolute(length) => match length { - AbsoluteLength::Pixels(pixels) => taffy::style::Dimension::Length(pixels.into()), + AbsoluteLength::Pixels(pixels) => taffy::style::Dimension::length(pixels.into()), AbsoluteLength::Rems(rems) => { - taffy::style::Dimension::Length((*rems * rem_size).into()) + taffy::style::Dimension::length((*rems * rem_size).into()) } }, - DefiniteLength::Fraction(fraction) => taffy::style::Dimension::Percent(*fraction), + DefiniteLength::Fraction(fraction) => taffy::style::Dimension::percent(*fraction), } } } @@ -350,9 +350,9 @@ impl ToTaffy for DefiniteLength { impl ToTaffy for AbsoluteLength { fn to_taffy(&self, rem_size: Pixels) -> taffy::style::LengthPercentage { match self { - AbsoluteLength::Pixels(pixels) => taffy::style::LengthPercentage::Length(pixels.into()), + AbsoluteLength::Pixels(pixels) => taffy::style::LengthPercentage::length(pixels.into()), AbsoluteLength::Rems(rems) => { - taffy::style::LengthPercentage::Length((*rems * rem_size).into()) + taffy::style::LengthPercentage::length((*rems * rem_size).into()) } } } From 4a87397d376331a4fd5189678a62269a427d714d Mon Sep 17 00:00:00 2001 From: Maksim Bondarenkov <119937608+ognevny@users.noreply.github.com> Date: Wed, 23 Jul 2025 22:53:13 +0000 Subject: [PATCH 011/893] livekit_client: Revert a change that broke MinGW builds (#34977) the change was made in https://github.com/zed-industries/zed/pull/34223 for unknown reason. it wasn't required actually, and the code can be safely left as before update: after this revert Zed compiles with MinGW as before Release Notes: - N/A --- crates/livekit_client/src/lib.rs | 35 +++++++++++++++++++++++++++----- 1 file changed, 30 insertions(+), 5 deletions(-) diff --git a/crates/livekit_client/src/lib.rs b/crates/livekit_client/src/lib.rs index f94181b8f8..149859fdc8 100644 --- a/crates/livekit_client/src/lib.rs +++ b/crates/livekit_client/src/lib.rs @@ -3,16 +3,41 @@ use collections::HashMap; mod remote_video_track_view; pub use remote_video_track_view::{RemoteVideoTrackView, RemoteVideoTrackViewEvent}; -#[cfg(not(any(test, feature = "test-support", target_os = "freebsd")))] +#[cfg(not(any( + test, + feature = "test-support", + all(target_os = "windows", target_env = "gnu"), + target_os = "freebsd" +)))] mod livekit_client; -#[cfg(not(any(test, feature = "test-support", target_os = "freebsd")))] +#[cfg(not(any( + test, + feature = "test-support", + all(target_os = "windows", target_env = "gnu"), + target_os = "freebsd" +)))] pub use livekit_client::*; -#[cfg(any(test, feature = "test-support", target_os = "freebsd"))] +#[cfg(any( + test, + feature = "test-support", + all(target_os = "windows", target_env = "gnu"), + target_os = "freebsd" +))] mod mock_client; -#[cfg(any(test, feature = "test-support", target_os = "freebsd"))] +#[cfg(any( + test, + feature = "test-support", + all(target_os = "windows", target_env = "gnu"), + target_os = "freebsd" +))] pub mod test; -#[cfg(any(test, feature = "test-support", target_os = "freebsd"))] +#[cfg(any( + test, + feature = "test-support", + all(target_os = "windows", target_env = "gnu"), + target_os = "freebsd" +))] pub use mock_client::*; #[derive(Debug, Clone)] From 3d4266bb8f23d6982eaa49e47c296c717287a662 Mon Sep 17 00:00:00 2001 From: Marshall Bowers Date: Wed, 23 Jul 2025 19:30:00 -0400 Subject: [PATCH 012/893] collab: Remove `POST /billing/subscriptions/manage` endpoint (#34986) This PR removes the `POST /billing/subscriptions/manage` endpoint, as it has been moved to `cloud.zed.dev`. Release Notes: - N/A --- crates/collab/src/api/billing.rs | 272 +------------------------------ 1 file changed, 7 insertions(+), 265 deletions(-) diff --git a/crates/collab/src/api/billing.rs b/crates/collab/src/api/billing.rs index bd7b99b3eb..9a27e22f87 100644 --- a/crates/collab/src/api/billing.rs +++ b/crates/collab/src/api/billing.rs @@ -5,16 +5,8 @@ use collections::{HashMap, HashSet}; use reqwest::StatusCode; use sea_orm::ActiveValue; use serde::{Deserialize, Serialize}; -use std::{str::FromStr, sync::Arc, time::Duration}; -use stripe::{ - BillingPortalSession, CancellationDetailsReason, CreateBillingPortalSession, - CreateBillingPortalSessionFlowData, CreateBillingPortalSessionFlowDataAfterCompletion, - CreateBillingPortalSessionFlowDataAfterCompletionRedirect, - CreateBillingPortalSessionFlowDataSubscriptionUpdateConfirm, - CreateBillingPortalSessionFlowDataSubscriptionUpdateConfirmItems, - CreateBillingPortalSessionFlowDataType, CustomerId, EventObject, EventType, ListEvents, - PaymentMethod, Subscription, SubscriptionId, SubscriptionStatus, -}; +use std::{sync::Arc, time::Duration}; +use stripe::{CancellationDetailsReason, EventObject, EventType, ListEvents, SubscriptionStatus}; use util::{ResultExt, maybe}; use zed_llm_client::LanguageModelProvider; @@ -31,7 +23,7 @@ use crate::{AppState, Error, Result}; use crate::{db::UserId, llm::db::LlmDatabase}; use crate::{ db::{ - BillingSubscriptionId, CreateBillingCustomerParams, CreateBillingSubscriptionParams, + CreateBillingCustomerParams, CreateBillingSubscriptionParams, CreateProcessedStripeEventParams, UpdateBillingCustomerParams, UpdateBillingSubscriptionParams, billing_customer, }, @@ -39,260 +31,10 @@ use crate::{ }; pub fn router() -> Router { - Router::new() - .route( - "/billing/subscriptions/manage", - post(manage_billing_subscription), - ) - .route( - "/billing/subscriptions/sync", - post(sync_billing_subscription), - ) -} - -#[derive(Debug, PartialEq, Deserialize)] -#[serde(rename_all = "snake_case")] -enum ManageSubscriptionIntent { - /// The user intends to manage their subscription. - /// - /// This will open the Stripe billing portal without putting the user in a specific flow. - ManageSubscription, - /// The user intends to update their payment method. - UpdatePaymentMethod, - /// The user intends to upgrade to Zed Pro. - UpgradeToPro, - /// The user intends to cancel their subscription. - Cancel, - /// The user intends to stop the cancellation of their subscription. - StopCancellation, -} - -#[derive(Debug, Deserialize)] -struct ManageBillingSubscriptionBody { - github_user_id: i32, - intent: ManageSubscriptionIntent, - /// The ID of the subscription to manage. - subscription_id: BillingSubscriptionId, - redirect_to: Option, -} - -#[derive(Debug, Serialize)] -struct ManageBillingSubscriptionResponse { - billing_portal_session_url: Option, -} - -/// Initiates a Stripe customer portal session for managing a billing subscription. -async fn manage_billing_subscription( - Extension(app): Extension>, - extract::Json(body): extract::Json, -) -> Result> { - let user = app - .db - .get_user_by_github_user_id(body.github_user_id) - .await? - .context("user not found")?; - - let Some(stripe_client) = app.real_stripe_client.clone() else { - log::error!("failed to retrieve Stripe client"); - Err(Error::http( - StatusCode::NOT_IMPLEMENTED, - "not supported".into(), - ))? - }; - - let Some(stripe_billing) = app.stripe_billing.clone() else { - log::error!("failed to retrieve Stripe billing object"); - Err(Error::http( - StatusCode::NOT_IMPLEMENTED, - "not supported".into(), - ))? - }; - - let customer = app - .db - .get_billing_customer_by_user_id(user.id) - .await? - .context("billing customer not found")?; - let customer_id = CustomerId::from_str(&customer.stripe_customer_id) - .context("failed to parse customer ID")?; - - let subscription = app - .db - .get_billing_subscription_by_id(body.subscription_id) - .await? - .context("subscription not found")?; - let subscription_id = SubscriptionId::from_str(&subscription.stripe_subscription_id) - .context("failed to parse subscription ID")?; - - if body.intent == ManageSubscriptionIntent::StopCancellation { - let updated_stripe_subscription = Subscription::update( - &stripe_client, - &subscription_id, - stripe::UpdateSubscription { - cancel_at_period_end: Some(false), - ..Default::default() - }, - ) - .await?; - - app.db - .update_billing_subscription( - subscription.id, - &UpdateBillingSubscriptionParams { - stripe_cancel_at: ActiveValue::set( - updated_stripe_subscription - .cancel_at - .and_then(|cancel_at| DateTime::from_timestamp(cancel_at, 0)) - .map(|time| time.naive_utc()), - ), - ..Default::default() - }, - ) - .await?; - - return Ok(Json(ManageBillingSubscriptionResponse { - billing_portal_session_url: None, - })); - } - - let flow = match body.intent { - ManageSubscriptionIntent::ManageSubscription => None, - ManageSubscriptionIntent::UpgradeToPro => { - let zed_pro_price_id: stripe::PriceId = - stripe_billing.zed_pro_price_id().await?.try_into()?; - let zed_free_price_id: stripe::PriceId = - stripe_billing.zed_free_price_id().await?.try_into()?; - - let stripe_subscription = - Subscription::retrieve(&stripe_client, &subscription_id, &[]).await?; - - let is_on_zed_pro_trial = stripe_subscription.status == SubscriptionStatus::Trialing - && stripe_subscription.items.data.iter().any(|item| { - item.price - .as_ref() - .map_or(false, |price| price.id == zed_pro_price_id) - }); - if is_on_zed_pro_trial { - let payment_methods = PaymentMethod::list( - &stripe_client, - &stripe::ListPaymentMethods { - customer: Some(stripe_subscription.customer.id()), - ..Default::default() - }, - ) - .await?; - - let has_payment_method = !payment_methods.data.is_empty(); - if !has_payment_method { - return Err(Error::http( - StatusCode::BAD_REQUEST, - "missing payment method".into(), - )); - } - - // If the user is already on a Zed Pro trial and wants to upgrade to Pro, we just need to end their trial early. - Subscription::update( - &stripe_client, - &stripe_subscription.id, - stripe::UpdateSubscription { - trial_end: Some(stripe::Scheduled::now()), - ..Default::default() - }, - ) - .await?; - - return Ok(Json(ManageBillingSubscriptionResponse { - billing_portal_session_url: None, - })); - } - - let subscription_item_to_update = stripe_subscription - .items - .data - .iter() - .find_map(|item| { - let price = item.price.as_ref()?; - - if price.id == zed_free_price_id { - Some(item.id.clone()) - } else { - None - } - }) - .context("No subscription item to update")?; - - Some(CreateBillingPortalSessionFlowData { - type_: CreateBillingPortalSessionFlowDataType::SubscriptionUpdateConfirm, - subscription_update_confirm: Some( - CreateBillingPortalSessionFlowDataSubscriptionUpdateConfirm { - subscription: subscription.stripe_subscription_id, - items: vec![ - CreateBillingPortalSessionFlowDataSubscriptionUpdateConfirmItems { - id: subscription_item_to_update.to_string(), - price: Some(zed_pro_price_id.to_string()), - quantity: Some(1), - }, - ], - discounts: None, - }, - ), - ..Default::default() - }) - } - ManageSubscriptionIntent::UpdatePaymentMethod => Some(CreateBillingPortalSessionFlowData { - type_: CreateBillingPortalSessionFlowDataType::PaymentMethodUpdate, - after_completion: Some(CreateBillingPortalSessionFlowDataAfterCompletion { - type_: stripe::CreateBillingPortalSessionFlowDataAfterCompletionType::Redirect, - redirect: Some(CreateBillingPortalSessionFlowDataAfterCompletionRedirect { - return_url: format!( - "{}{path}", - app.config.zed_dot_dev_url(), - path = body.redirect_to.unwrap_or_else(|| "/account".to_string()) - ), - }), - ..Default::default() - }), - ..Default::default() - }), - ManageSubscriptionIntent::Cancel => { - if subscription.kind == Some(SubscriptionKind::ZedFree) { - return Err(Error::http( - StatusCode::BAD_REQUEST, - "free subscription cannot be canceled".into(), - )); - } - - Some(CreateBillingPortalSessionFlowData { - type_: CreateBillingPortalSessionFlowDataType::SubscriptionCancel, - after_completion: Some(CreateBillingPortalSessionFlowDataAfterCompletion { - type_: stripe::CreateBillingPortalSessionFlowDataAfterCompletionType::Redirect, - redirect: Some(CreateBillingPortalSessionFlowDataAfterCompletionRedirect { - return_url: format!("{}/account", app.config.zed_dot_dev_url()), - }), - ..Default::default() - }), - subscription_cancel: Some( - stripe::CreateBillingPortalSessionFlowDataSubscriptionCancel { - subscription: subscription.stripe_subscription_id, - retention: None, - }, - ), - ..Default::default() - }) - } - ManageSubscriptionIntent::StopCancellation => unreachable!(), - }; - - let mut params = CreateBillingPortalSession::new(customer_id); - params.flow_data = flow; - let return_url = format!("{}/account", app.config.zed_dot_dev_url()); - params.return_url = Some(&return_url); - - let session = BillingPortalSession::create(&stripe_client, params).await?; - - Ok(Json(ManageBillingSubscriptionResponse { - billing_portal_session_url: Some(session.url), - })) + Router::new().route( + "/billing/subscriptions/sync", + post(sync_billing_subscription), + ) } #[derive(Debug, Deserialize)] From 31afda3c0c3ea326cbec7e3d99a0d334ad7d638b Mon Sep 17 00:00:00 2001 From: Smit Barmase Date: Thu, 24 Jul 2025 05:26:12 +0530 Subject: [PATCH 013/893] project_panel: Automatically open project panel when Rename or Duplicate is triggered from workspace (#34988) In project panel, `rename` and `duplicate` action further needs user input for editing, so if panel is closed we should open it. Release Notes: - Fixed project panel not opening when `project panel: rename` and `project panel: duplicate` actions are triggered from workspace. --- crates/project_panel/src/project_panel.rs | 2 ++ 1 file changed, 2 insertions(+) diff --git a/crates/project_panel/src/project_panel.rs b/crates/project_panel/src/project_panel.rs index 44f4e8985a..b0073f294f 100644 --- a/crates/project_panel/src/project_panel.rs +++ b/crates/project_panel/src/project_panel.rs @@ -322,6 +322,7 @@ pub fn init(cx: &mut App) { }); workspace.register_action(|workspace, action: &Rename, window, cx| { + workspace.open_panel::(window, cx); if let Some(panel) = workspace.panel::(cx) { panel.update(cx, |panel, cx| { if let Some(first_marked) = panel.marked_entries.first() { @@ -335,6 +336,7 @@ pub fn init(cx: &mut App) { }); workspace.register_action(|workspace, action: &Duplicate, window, cx| { + workspace.open_panel::(window, cx); if let Some(panel) = workspace.panel::(cx) { panel.update(cx, |panel, cx| { panel.duplicate(action, window, cx); From 67027bb241ef1a0f4de60aace75539a60fa867c8 Mon Sep 17 00:00:00 2001 From: Piotr Osiewicz <24362066+osiewicz@users.noreply.github.com> Date: Thu, 24 Jul 2025 02:13:47 +0200 Subject: [PATCH 014/893] agent: Fix Zed header in settings view (#34993) Follow-up to taffy bump (#34939), fixes an issue reported by @MrSubidubi Release Notes: - N/A --- crates/agent_ui/src/agent_configuration.rs | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/crates/agent_ui/src/agent_configuration.rs b/crates/agent_ui/src/agent_configuration.rs index 334c5ee6dc..7a160a5649 100644 --- a/crates/agent_ui/src/agent_configuration.rs +++ b/crates/agent_ui/src/agent_configuration.rs @@ -186,6 +186,7 @@ impl AgentConfiguration { }; v_flex() + .w_full() .when(is_expanded, |this| this.mb_2()) .child( div() @@ -216,6 +217,7 @@ impl AgentConfiguration { .hover(|hover| hover.bg(cx.theme().colors().element_hover)) .child( h_flex() + .w_full() .gap_2() .child( Icon::new(provider.icon()) @@ -224,6 +226,7 @@ impl AgentConfiguration { ) .child( h_flex() + .w_full() .gap_1() .child( Label::new(provider_name.clone()) @@ -307,6 +310,7 @@ impl AgentConfiguration { let providers = LanguageModelRegistry::read_global(cx).providers(); v_flex() + .w_full() .child( h_flex() .p(DynamicSpacing::Base16.rems(cx)) @@ -361,6 +365,7 @@ impl AgentConfiguration { ) .child( div() + .w_full() .pl(DynamicSpacing::Base08.rems(cx)) .pr(DynamicSpacing::Base20.rems(cx)) .children( From b93e1c736b33615e0b80a8e7fb3a294f40c70862 Mon Sep 17 00:00:00 2001 From: Peter Tripp Date: Wed, 23 Jul 2025 23:13:49 -0400 Subject: [PATCH 015/893] mistral: Add support for magistral-small and magistral-medium (#34983) Release Notes: - mistral: Added support for magistral-small and magistral-medium --- crates/mistral/src/mistral.rs | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) diff --git a/crates/mistral/src/mistral.rs b/crates/mistral/src/mistral.rs index bf6ccf2883..c466a598a0 100644 --- a/crates/mistral/src/mistral.rs +++ b/crates/mistral/src/mistral.rs @@ -48,20 +48,29 @@ pub enum Model { #[serde(rename = "codestral-latest", alias = "codestral-latest")] #[default] CodestralLatest, + #[serde(rename = "mistral-large-latest", alias = "mistral-large-latest")] MistralLargeLatest, #[serde(rename = "mistral-medium-latest", alias = "mistral-medium-latest")] MistralMediumLatest, #[serde(rename = "mistral-small-latest", alias = "mistral-small-latest")] MistralSmallLatest, + + #[serde(rename = "magistral-medium-latest", alias = "magistral-medium-latest")] + MagistralMediumLatest, + #[serde(rename = "magistral-small-latest", alias = "magistral-small-latest")] + MagistralSmallLatest, + #[serde(rename = "open-mistral-nemo", alias = "open-mistral-nemo")] OpenMistralNemo, #[serde(rename = "open-codestral-mamba", alias = "open-codestral-mamba")] OpenCodestralMamba, + #[serde(rename = "devstral-medium-latest", alias = "devstral-medium-latest")] DevstralMediumLatest, #[serde(rename = "devstral-small-latest", alias = "devstral-small-latest")] DevstralSmallLatest, + #[serde(rename = "pixtral-12b-latest", alias = "pixtral-12b-latest")] Pixtral12BLatest, #[serde(rename = "pixtral-large-latest", alias = "pixtral-large-latest")] @@ -91,6 +100,8 @@ impl Model { "mistral-large-latest" => Ok(Self::MistralLargeLatest), "mistral-medium-latest" => Ok(Self::MistralMediumLatest), "mistral-small-latest" => Ok(Self::MistralSmallLatest), + "magistral-medium-latest" => Ok(Self::MagistralMediumLatest), + "magistral-small-latest" => Ok(Self::MagistralSmallLatest), "open-mistral-nemo" => Ok(Self::OpenMistralNemo), "open-codestral-mamba" => Ok(Self::OpenCodestralMamba), "devstral-medium-latest" => Ok(Self::DevstralMediumLatest), @@ -107,6 +118,8 @@ impl Model { Self::MistralLargeLatest => "mistral-large-latest", Self::MistralMediumLatest => "mistral-medium-latest", Self::MistralSmallLatest => "mistral-small-latest", + Self::MagistralMediumLatest => "magistral-medium-latest", + Self::MagistralSmallLatest => "magistral-small-latest", Self::OpenMistralNemo => "open-mistral-nemo", Self::OpenCodestralMamba => "open-codestral-mamba", Self::DevstralMediumLatest => "devstral-medium-latest", @@ -123,6 +136,8 @@ impl Model { Self::MistralLargeLatest => "mistral-large-latest", Self::MistralMediumLatest => "mistral-medium-latest", Self::MistralSmallLatest => "mistral-small-latest", + Self::MagistralMediumLatest => "magistral-medium-latest", + Self::MagistralSmallLatest => "magistral-small-latest", Self::OpenMistralNemo => "open-mistral-nemo", Self::OpenCodestralMamba => "open-codestral-mamba", Self::DevstralMediumLatest => "devstral-medium-latest", @@ -141,6 +156,8 @@ impl Model { Self::MistralLargeLatest => 131000, Self::MistralMediumLatest => 128000, Self::MistralSmallLatest => 32000, + Self::MagistralMediumLatest => 40000, + Self::MagistralSmallLatest => 40000, Self::OpenMistralNemo => 131000, Self::OpenCodestralMamba => 256000, Self::DevstralMediumLatest => 128000, @@ -166,6 +183,8 @@ impl Model { | Self::MistralLargeLatest | Self::MistralMediumLatest | Self::MistralSmallLatest + | Self::MagistralMediumLatest + | Self::MagistralSmallLatest | Self::OpenMistralNemo | Self::OpenCodestralMamba | Self::DevstralMediumLatest @@ -184,6 +203,8 @@ impl Model { | Self::MistralSmallLatest => true, Self::CodestralLatest | Self::MistralLargeLatest + | Self::MagistralMediumLatest + | Self::MagistralSmallLatest | Self::OpenMistralNemo | Self::OpenCodestralMamba | Self::DevstralMediumLatest From c08851a85ea4e3a495cbc8cb951b06353ccfa015 Mon Sep 17 00:00:00 2001 From: versecafe <147033096+versecafe@users.noreply.github.com> Date: Wed, 23 Jul 2025 21:17:54 -0700 Subject: [PATCH 016/893] ollama: Add Magistral to Ollama (#35000) See also: #34983 Release Notes: - Added magistral support to ollama --- crates/ollama/src/ollama.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/crates/ollama/src/ollama.rs b/crates/ollama/src/ollama.rs index 109fea7353..62c32b4161 100644 --- a/crates/ollama/src/ollama.rs +++ b/crates/ollama/src/ollama.rs @@ -55,6 +55,7 @@ fn get_max_tokens(name: &str) -> u64 { "codellama" | "starcoder2" => 16384, "mistral" | "codestral" | "mixstral" | "llava" | "qwen2" | "qwen2.5-coder" | "dolphin-mixtral" => 32768, + "magistral" => 40000, "llama3.1" | "llama3.2" | "llama3.3" | "phi3" | "phi3.5" | "phi4" | "command-r" | "qwen3" | "gemma3" | "deepseek-coder-v2" | "deepseek-v3" | "deepseek-r1" | "yi-coder" | "devstral" => 128000, From 8b0ec287a53aa41d56232088b280a1a25cb6e74d Mon Sep 17 00:00:00 2001 From: AidanV <84053180+AidanV@users.noreply.github.com> Date: Wed, 23 Jul 2025 22:06:05 -0700 Subject: [PATCH 017/893] vim: Add `:norm` support (#33232) Closes #21198 Release Notes: - Adds support for `:norm` - Allows for vim and zed style modified keys specified in issue - Vim style and zed style - Differs from vim in how multi-line is handled - vim is sequential - zed is combinational (with multi-cursor) --- crates/editor/src/editor.rs | 18 +- crates/vim/src/command.rs | 195 +++++++++++++++++- crates/vim/src/insert.rs | 2 +- crates/vim/test_data/test_normal_command.json | 64 ++++++ crates/workspace/src/workspace.rs | 97 +++++---- 5 files changed, 328 insertions(+), 48 deletions(-) create mode 100644 crates/vim/test_data/test_normal_command.json diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs index a695c8fd0c..069d8cffb3 100644 --- a/crates/editor/src/editor.rs +++ b/crates/editor/src/editor.rs @@ -16968,7 +16968,7 @@ impl Editor { now: Instant, window: &mut Window, cx: &mut Context, - ) { + ) -> Option { self.end_selection(window, cx); if let Some(tx_id) = self .buffer @@ -16978,7 +16978,10 @@ impl Editor { .insert_transaction(tx_id, self.selections.disjoint_anchors()); cx.emit(EditorEvent::TransactionBegun { transaction_id: tx_id, - }) + }); + Some(tx_id) + } else { + None } } @@ -17006,6 +17009,17 @@ impl Editor { } } + pub fn modify_transaction_selection_history( + &mut self, + transaction_id: TransactionId, + modify: impl FnOnce(&mut (Arc<[Selection]>, Option]>>)), + ) -> bool { + self.selection_history + .transaction_mut(transaction_id) + .map(modify) + .is_some() + } + pub fn set_mark(&mut self, _: &actions::SetMark, window: &mut Window, cx: &mut Context) { if self.selection_mark_mode { self.change_selections(SelectionEffects::no_scroll(), window, cx, |s| { diff --git a/crates/vim/src/command.rs b/crates/vim/src/command.rs index 23e04cae2c..7963db3571 100644 --- a/crates/vim/src/command.rs +++ b/crates/vim/src/command.rs @@ -6,7 +6,7 @@ use editor::{ actions::{SortLinesCaseInsensitive, SortLinesCaseSensitive}, display_map::ToDisplayPoint, }; -use gpui::{Action, App, AppContext as _, Context, Global, Window, actions}; +use gpui::{Action, App, AppContext as _, Context, Global, Keystroke, Window, actions}; use itertools::Itertools; use language::Point; use multi_buffer::MultiBufferRow; @@ -202,6 +202,7 @@ actions!( ArgumentRequired ] ); + /// Opens the specified file for editing. #[derive(Clone, PartialEq, Action)] #[action(namespace = vim, no_json, no_register)] @@ -209,6 +210,13 @@ struct VimEdit { pub filename: String, } +#[derive(Clone, PartialEq, Action)] +#[action(namespace = vim, no_json, no_register)] +struct VimNorm { + pub range: Option, + pub command: String, +} + #[derive(Debug)] struct WrappedAction(Box); @@ -447,6 +455,81 @@ pub fn register(editor: &mut Editor, cx: &mut Context) { }); }); + Vim::action(editor, cx, |vim, action: &VimNorm, window, cx| { + let keystrokes = action + .command + .chars() + .map(|c| Keystroke::parse(&c.to_string()).unwrap()) + .collect(); + vim.switch_mode(Mode::Normal, true, window, cx); + let initial_selections = vim.update_editor(window, cx, |_, editor, _, _| { + editor.selections.disjoint_anchors() + }); + if let Some(range) = &action.range { + let result = vim.update_editor(window, cx, |vim, editor, window, cx| { + let range = range.buffer_range(vim, editor, window, cx)?; + editor.change_selections( + SelectionEffects::no_scroll().nav_history(false), + window, + cx, + |s| { + s.select_ranges( + (range.start.0..=range.end.0) + .map(|line| Point::new(line, 0)..Point::new(line, 0)), + ); + }, + ); + anyhow::Ok(()) + }); + if let Some(Err(err)) = result { + log::error!("Error selecting range: {}", err); + return; + } + }; + + let Some(workspace) = vim.workspace(window) else { + return; + }; + let task = workspace.update(cx, |workspace, cx| { + workspace.send_keystrokes_impl(keystrokes, window, cx) + }); + let had_range = action.range.is_some(); + + cx.spawn_in(window, async move |vim, cx| { + task.await; + vim.update_in(cx, |vim, window, cx| { + vim.update_editor(window, cx, |_, editor, window, cx| { + if had_range { + editor.change_selections(SelectionEffects::default(), window, cx, |s| { + s.select_anchor_ranges([s.newest_anchor().range()]); + }) + } + }); + if matches!(vim.mode, Mode::Insert | Mode::Replace) { + vim.normal_before(&Default::default(), window, cx); + } else { + vim.switch_mode(Mode::Normal, true, window, cx); + } + vim.update_editor(window, cx, |_, editor, _, cx| { + if let Some(first_sel) = initial_selections { + if let Some(tx_id) = editor + .buffer() + .update(cx, |multi, cx| multi.last_transaction_id(cx)) + { + let last_sel = editor.selections.disjoint_anchors(); + editor.modify_transaction_selection_history(tx_id, |old| { + old.0 = first_sel; + old.1 = Some(last_sel); + }); + } + } + }); + }) + .ok(); + }) + .detach(); + }); + Vim::action(editor, cx, |vim, _: &CountCommand, window, cx| { let Some(workspace) = vim.workspace(window) else { return; @@ -675,14 +758,15 @@ impl VimCommand { } else { return None; }; - if !args.is_empty() { + + let action = if args.is_empty() { + action + } else { // if command does not accept args and we have args then we should do no action - if let Some(args_fn) = &self.args { - args_fn.deref()(action, args) - } else { - None - } - } else if let Some(range) = range { + self.args.as_ref()?(action, args)? + }; + + if let Some(range) = range { self.range.as_ref().and_then(|f| f(action, range)) } else { Some(action) @@ -1061,6 +1145,27 @@ fn generate_commands(_: &App) -> Vec { save_intent: Some(SaveIntent::Skip), close_pinned: true, }), + VimCommand::new( + ("norm", "al"), + VimNorm { + command: "".into(), + range: None, + }, + ) + .args(|_, args| { + Some( + VimNorm { + command: args, + range: None, + } + .boxed_clone(), + ) + }) + .range(|action, range| { + let mut action: VimNorm = action.as_any().downcast_ref::().unwrap().clone(); + action.range.replace(range.clone()); + Some(Box::new(action)) + }), VimCommand::new(("bn", "ext"), workspace::ActivateNextItem).count(), VimCommand::new(("bN", "ext"), workspace::ActivatePreviousItem).count(), VimCommand::new(("bp", "revious"), workspace::ActivatePreviousItem).count(), @@ -2298,4 +2403,78 @@ mod test { }); assert!(mark.is_none()) } + + #[gpui::test] + async fn test_normal_command(cx: &mut TestAppContext) { + let mut cx = NeovimBackedTestContext::new(cx).await; + + cx.set_shared_state(indoc! {" + The quick + brown« fox + jumpsˇ» over + the lazy dog + "}) + .await; + + cx.simulate_shared_keystrokes(": n o r m space w C w o r d") + .await; + cx.simulate_shared_keystrokes("enter").await; + + cx.shared_state().await.assert_eq(indoc! {" + The quick + brown word + jumps worˇd + the lazy dog + "}); + + cx.simulate_shared_keystrokes(": n o r m space _ w c i w t e s t") + .await; + cx.simulate_shared_keystrokes("enter").await; + + cx.shared_state().await.assert_eq(indoc! {" + The quick + brown word + jumps tesˇt + the lazy dog + "}); + + cx.simulate_shared_keystrokes("_ l v l : n o r m space s l a") + .await; + cx.simulate_shared_keystrokes("enter").await; + + cx.shared_state().await.assert_eq(indoc! {" + The quick + brown word + lˇaumps test + the lazy dog + "}); + + cx.set_shared_state(indoc! {" + ˇThe quick + brown fox + jumps over + the lazy dog + "}) + .await; + + cx.simulate_shared_keystrokes("c i w M y escape").await; + + cx.shared_state().await.assert_eq(indoc! {" + Mˇy quick + brown fox + jumps over + the lazy dog + "}); + + cx.simulate_shared_keystrokes(": n o r m space u").await; + cx.simulate_shared_keystrokes("enter").await; + + cx.shared_state().await.assert_eq(indoc! {" + ˇThe quick + brown fox + jumps over + the lazy dog + "}); + // Once ctrl-v to input character literals is added there should be a test for redo + } } diff --git a/crates/vim/src/insert.rs b/crates/vim/src/insert.rs index 89c60adee7..0a370e16ba 100644 --- a/crates/vim/src/insert.rs +++ b/crates/vim/src/insert.rs @@ -21,7 +21,7 @@ pub fn register(editor: &mut Editor, cx: &mut Context) { } impl Vim { - fn normal_before( + pub(crate) fn normal_before( &mut self, action: &NormalBefore, window: &mut Window, diff --git a/crates/vim/test_data/test_normal_command.json b/crates/vim/test_data/test_normal_command.json new file mode 100644 index 0000000000..efd1d532c4 --- /dev/null +++ b/crates/vim/test_data/test_normal_command.json @@ -0,0 +1,64 @@ +{"Put":{"state":"The quick\nbrown« fox\njumpsˇ» over\nthe lazy dog\n"}} +{"Key":":"} +{"Key":"n"} +{"Key":"o"} +{"Key":"r"} +{"Key":"m"} +{"Key":"space"} +{"Key":"w"} +{"Key":"C"} +{"Key":"w"} +{"Key":"o"} +{"Key":"r"} +{"Key":"d"} +{"Key":"enter"} +{"Get":{"state":"The quick\nbrown word\njumps worˇd\nthe lazy dog\n","mode":"Normal"}} +{"Key":":"} +{"Key":"n"} +{"Key":"o"} +{"Key":"r"} +{"Key":"m"} +{"Key":"space"} +{"Key":"_"} +{"Key":"w"} +{"Key":"c"} +{"Key":"i"} +{"Key":"w"} +{"Key":"t"} +{"Key":"e"} +{"Key":"s"} +{"Key":"t"} +{"Key":"enter"} +{"Get":{"state":"The quick\nbrown word\njumps tesˇt\nthe lazy dog\n","mode":"Normal"}} +{"Key":"_"} +{"Key":"l"} +{"Key":"v"} +{"Key":"l"} +{"Key":":"} +{"Key":"n"} +{"Key":"o"} +{"Key":"r"} +{"Key":"m"} +{"Key":"space"} +{"Key":"s"} +{"Key":"l"} +{"Key":"a"} +{"Key":"enter"} +{"Get":{"state":"The quick\nbrown word\nlˇaumps test\nthe lazy dog\n","mode":"Normal"}} +{"Put":{"state":"ˇThe quick\nbrown fox\njumps over\nthe lazy dog\n"}} +{"Key":"c"} +{"Key":"i"} +{"Key":"w"} +{"Key":"M"} +{"Key":"y"} +{"Key":"escape"} +{"Get":{"state":"Mˇy quick\nbrown fox\njumps over\nthe lazy dog\n","mode":"Normal"}} +{"Key":":"} +{"Key":"n"} +{"Key":"o"} +{"Key":"r"} +{"Key":"m"} +{"Key":"space"} +{"Key":"u"} +{"Key":"enter"} +{"Get":{"state":"ˇThe quick\nbrown fox\njumps over\nthe lazy dog\n","mode":"Normal"}} diff --git a/crates/workspace/src/workspace.rs b/crates/workspace/src/workspace.rs index 4c70c52d5a..0ee8177dd8 100644 --- a/crates/workspace/src/workspace.rs +++ b/crates/workspace/src/workspace.rs @@ -32,7 +32,7 @@ use futures::{ mpsc::{self, UnboundedReceiver, UnboundedSender}, oneshot, }, - future::try_join_all, + future::{Shared, try_join_all}, }; use gpui::{ Action, AnyEntity, AnyView, AnyWeakView, App, AsyncApp, AsyncWindowContext, Bounds, Context, @@ -87,7 +87,7 @@ use std::{ borrow::Cow, cell::RefCell, cmp, - collections::hash_map::DefaultHasher, + collections::{VecDeque, hash_map::DefaultHasher}, env, hash::{Hash, Hasher}, path::{Path, PathBuf}, @@ -1043,6 +1043,13 @@ type PromptForOpenPath = Box< ) -> oneshot::Receiver>>, >; +#[derive(Default)] +struct DispatchingKeystrokes { + dispatched: HashSet>, + queue: VecDeque, + task: Option>>, +} + /// Collects everything project-related for a certain window opened. /// In some way, is a counterpart of a window, as the [`WindowHandle`] could be downcast into `Workspace`. /// @@ -1080,7 +1087,7 @@ pub struct Workspace { leader_updates_tx: mpsc::UnboundedSender<(PeerId, proto::UpdateFollowers)>, database_id: Option, app_state: Arc, - dispatching_keystrokes: Rc, Vec)>>, + dispatching_keystrokes: Rc>, _subscriptions: Vec, _apply_leader_updates: Task>, _observe_current_user: Task>, @@ -2311,49 +2318,65 @@ impl Workspace { window: &mut Window, cx: &mut Context, ) { - let mut state = self.dispatching_keystrokes.borrow_mut(); - if !state.0.insert(action.0.clone()) { - cx.propagate(); - return; - } - let mut keystrokes: Vec = action + let keystrokes: Vec = action .0 .split(' ') .flat_map(|k| Keystroke::parse(k).log_err()) .collect(); - keystrokes.reverse(); + let _ = self.send_keystrokes_impl(keystrokes, window, cx); + } - state.1.append(&mut keystrokes); - drop(state); + pub fn send_keystrokes_impl( + &mut self, + keystrokes: Vec, + window: &mut Window, + cx: &mut Context, + ) -> Shared> { + let mut state = self.dispatching_keystrokes.borrow_mut(); + if !state.dispatched.insert(keystrokes.clone()) { + cx.propagate(); + return state.task.clone().unwrap(); + } + + state.queue.extend(keystrokes); let keystrokes = self.dispatching_keystrokes.clone(); - window - .spawn(cx, async move |cx| { - // limit to 100 keystrokes to avoid infinite recursion. - for _ in 0..100 { - let Some(keystroke) = keystrokes.borrow_mut().1.pop() else { - keystrokes.borrow_mut().0.clear(); - return Ok(()); - }; - cx.update(|window, cx| { - let focused = window.focused(cx); - window.dispatch_keystroke(keystroke.clone(), cx); - if window.focused(cx) != focused { - // dispatch_keystroke may cause the focus to change. - // draw's side effect is to schedule the FocusChanged events in the current flush effect cycle - // And we need that to happen before the next keystroke to keep vim mode happy... - // (Note that the tests always do this implicitly, so you must manually test with something like: - // "bindings": { "g z": ["workspace::SendKeystrokes", ": j u"]} - // ) - window.draw(cx).clear(); + if state.task.is_none() { + state.task = Some( + window + .spawn(cx, async move |cx| { + // limit to 100 keystrokes to avoid infinite recursion. + for _ in 0..100 { + let mut state = keystrokes.borrow_mut(); + let Some(keystroke) = state.queue.pop_front() else { + state.dispatched.clear(); + state.task.take(); + return; + }; + drop(state); + cx.update(|window, cx| { + let focused = window.focused(cx); + window.dispatch_keystroke(keystroke.clone(), cx); + if window.focused(cx) != focused { + // dispatch_keystroke may cause the focus to change. + // draw's side effect is to schedule the FocusChanged events in the current flush effect cycle + // And we need that to happen before the next keystroke to keep vim mode happy... + // (Note that the tests always do this implicitly, so you must manually test with something like: + // "bindings": { "g z": ["workspace::SendKeystrokes", ": j u"]} + // ) + window.draw(cx).clear(); + } + }) + .ok(); } - })?; - } - *keystrokes.borrow_mut() = Default::default(); - anyhow::bail!("over 100 keystrokes passed to send_keystrokes"); - }) - .detach_and_log_err(cx); + *keystrokes.borrow_mut() = Default::default(); + log::error!("over 100 keystrokes passed to send_keystrokes"); + }) + .shared(), + ); + } + state.task.clone().unwrap() } fn save_all_internal( From a6956eebcbf87ed36fe3cc82bd204b8ae6b997f0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Pablo=20Ram=C3=B3n=20Guevara?= <50140021+praguevara@users.noreply.github.com> Date: Thu, 24 Jul 2025 07:27:07 +0200 Subject: [PATCH 018/893] Improve Helix insert (#34765) Closes #34763 Release Notes: - Improved insert in `helix_mode` when a selection exists to better match helix's behavior: collapse selection to avoid replacing it - Improved append (`insert_after`) to better match helix's behavior: move cursor to end of selection if it exists --- assets/keymaps/vim.json | 6 ++- crates/vim/src/helix.rs | 110 +++++++++++++++++++++++++++++++++++++++- 2 files changed, 112 insertions(+), 4 deletions(-) diff --git a/assets/keymaps/vim.json b/assets/keymaps/vim.json index d0cf4621a5..6458ac1510 100644 --- a/assets/keymaps/vim.json +++ b/assets/keymaps/vim.json @@ -220,6 +220,8 @@ { "context": "vim_mode == normal", "bindings": { + "i": "vim::InsertBefore", + "a": "vim::InsertAfter", "ctrl-[": "editor::Cancel", ":": "command_palette::Toggle", "c": "vim::PushChange", @@ -353,9 +355,7 @@ "shift-d": "vim::DeleteToEndOfLine", "shift-j": "vim::JoinLines", "shift-y": "vim::YankLine", - "i": "vim::InsertBefore", "shift-i": "vim::InsertFirstNonWhitespace", - "a": "vim::InsertAfter", "shift-a": "vim::InsertEndOfLine", "o": "vim::InsertLineBelow", "shift-o": "vim::InsertLineAbove", @@ -377,6 +377,8 @@ { "context": "vim_mode == helix_normal && !menu", "bindings": { + "i": "vim::HelixInsert", + "a": "vim::HelixAppend", "ctrl-[": "editor::Cancel", ";": "vim::HelixCollapseSelection", ":": "command_palette::Toggle", diff --git a/crates/vim/src/helix.rs b/crates/vim/src/helix.rs index ec9b959b12..798af3bff3 100644 --- a/crates/vim/src/helix.rs +++ b/crates/vim/src/helix.rs @@ -4,18 +4,28 @@ use gpui::{Context, Window}; use language::{CharClassifier, CharKind}; use text::SelectionGoal; -use crate::{Vim, motion::Motion, state::Mode}; +use crate::{ + Vim, + motion::{Motion, right}, + state::Mode, +}; actions!( vim, [ /// Switches to normal mode after the cursor (Helix-style). - HelixNormalAfter + HelixNormalAfter, + /// Inserts at the beginning of the selection. + HelixInsert, + /// Appends at the end of the selection. + HelixAppend, ] ); pub fn register(editor: &mut Editor, cx: &mut Context) { Vim::action(editor, cx, Vim::helix_normal_after); + Vim::action(editor, cx, Vim::helix_insert); + Vim::action(editor, cx, Vim::helix_append); } impl Vim { @@ -299,6 +309,38 @@ impl Vim { _ => self.helix_move_and_collapse(motion, times, window, cx), } } + + fn helix_insert(&mut self, _: &HelixInsert, window: &mut Window, cx: &mut Context) { + self.start_recording(cx); + self.update_editor(window, cx, |_, editor, window, cx| { + editor.change_selections(Default::default(), window, cx, |s| { + s.move_with(|_map, selection| { + // In helix normal mode, move cursor to start of selection and collapse + if !selection.is_empty() { + selection.collapse_to(selection.start, SelectionGoal::None); + } + }); + }); + }); + self.switch_mode(Mode::Insert, false, window, cx); + } + + fn helix_append(&mut self, _: &HelixAppend, window: &mut Window, cx: &mut Context) { + self.start_recording(cx); + self.switch_mode(Mode::Insert, false, window, cx); + self.update_editor(window, cx, |_, editor, window, cx| { + editor.change_selections(Default::default(), window, cx, |s| { + s.move_with(|map, selection| { + let point = if selection.is_empty() { + right(map, selection.head(), 1) + } else { + selection.end + }; + selection.collapse_to(point, SelectionGoal::None); + }); + }); + }); + } } #[cfg(test)] @@ -497,4 +539,68 @@ mod test { cx.assert_state("«ˇaa»\n", Mode::HelixNormal); } + + #[gpui::test] + async fn test_insert_selected(cx: &mut gpui::TestAppContext) { + let mut cx = VimTestContext::new(cx, true).await; + cx.set_state( + indoc! {" + «The ˇ»quick brown + fox jumps over + the lazy dog."}, + Mode::HelixNormal, + ); + + cx.simulate_keystrokes("i"); + + cx.assert_state( + indoc! {" + ˇThe quick brown + fox jumps over + the lazy dog."}, + Mode::Insert, + ); + } + + #[gpui::test] + async fn test_append(cx: &mut gpui::TestAppContext) { + let mut cx = VimTestContext::new(cx, true).await; + // test from the end of the selection + cx.set_state( + indoc! {" + «Theˇ» quick brown + fox jumps over + the lazy dog."}, + Mode::HelixNormal, + ); + + cx.simulate_keystrokes("a"); + + cx.assert_state( + indoc! {" + Theˇ quick brown + fox jumps over + the lazy dog."}, + Mode::Insert, + ); + + // test from the beginning of the selection + cx.set_state( + indoc! {" + «ˇThe» quick brown + fox jumps over + the lazy dog."}, + Mode::HelixNormal, + ); + + cx.simulate_keystrokes("a"); + + cx.assert_state( + indoc! {" + Theˇ quick brown + fox jumps over + the lazy dog."}, + Mode::Insert, + ); + } } From 34bf6ebba68cdbff01dfb4b3ff3c3a9c63240c08 Mon Sep 17 00:00:00 2001 From: Conrad Irwin Date: Wed, 23 Jul 2025 23:45:01 -0600 Subject: [PATCH 019/893] Disable auto-close in search (#35005) Currently if you type `\(`, it auto-closes to `\()` which is broken. It's arguably nice that if you type `(` it auto-closes to `()`, but I am much more likely to be looking for a function call `name\(` than to be starting a group in search. Release Notes: - search: Regex search will no longer try to close parenthesis automatically. --- crates/search/src/buffer_search.rs | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/crates/search/src/buffer_search.rs b/crates/search/src/buffer_search.rs index c2590ec9b0..91b7fe488e 100644 --- a/crates/search/src/buffer_search.rs +++ b/crates/search/src/buffer_search.rs @@ -700,7 +700,11 @@ impl BufferSearchBar { window: &mut Window, cx: &mut Context, ) -> Self { - let query_editor = cx.new(|cx| Editor::single_line(window, cx)); + let query_editor = cx.new(|cx| { + let mut editor = Editor::single_line(window, cx); + editor.set_use_autoclose(false); + editor + }); cx.subscribe_in(&query_editor, window, Self::on_query_editor_event) .detach(); let replacement_editor = cx.new(|cx| Editor::single_line(window, cx)); From ddd50aabbad67db1174255b2ce4743794b9618d9 Mon Sep 17 00:00:00 2001 From: "Joseph T. Lyons" Date: Thu, 24 Jul 2025 02:52:02 -0400 Subject: [PATCH 020/893] Fix some bugs with `editor: diff clipboard with selection` (#34999) Improves testing around `editor: diff clipboard with selection` as well. Release Notes: - Fixed some bugs with `editor: diff clipboard with selection` --- crates/editor/src/editor_tests.rs | 2 +- crates/git_ui/src/text_diff_view.rs | 340 +++++++++++++++++++++------- 2 files changed, 264 insertions(+), 78 deletions(-) diff --git a/crates/editor/src/editor_tests.rs b/crates/editor/src/editor_tests.rs index 0d69c067ee..8d121972d0 100644 --- a/crates/editor/src/editor_tests.rs +++ b/crates/editor/src/editor_tests.rs @@ -16864,7 +16864,7 @@ async fn test_multibuffer_reverts(cx: &mut TestAppContext) { } #[gpui::test] -async fn test_mutlibuffer_in_navigation_history(cx: &mut TestAppContext) { +async fn test_multibuffer_in_navigation_history(cx: &mut TestAppContext) { init_test(cx, |_| {}); let cols = 4; diff --git a/crates/git_ui/src/text_diff_view.rs b/crates/git_ui/src/text_diff_view.rs index e7386cf7bd..be1866a354 100644 --- a/crates/git_ui/src/text_diff_view.rs +++ b/crates/git_ui/src/text_diff_view.rs @@ -12,6 +12,7 @@ use language::{self, Buffer, Point}; use project::Project; use std::{ any::{Any, TypeId}, + cmp, ops::Range, pin::pin, sync::Arc, @@ -45,38 +46,60 @@ impl TextDiffView { ) -> Option>>> { let source_editor = diff_data.editor.clone(); - let source_editor_buffer_and_range = source_editor.update(cx, |editor, cx| { + let selection_data = source_editor.update(cx, |editor, cx| { let multibuffer = editor.buffer().read(cx); let source_buffer = multibuffer.as_singleton()?.clone(); let selections = editor.selections.all::(cx); let buffer_snapshot = source_buffer.read(cx); let first_selection = selections.first()?; - let selection_range = if first_selection.is_empty() { - Point::new(0, 0)..buffer_snapshot.max_point() - } else { - first_selection.start..first_selection.end - }; + let max_point = buffer_snapshot.max_point(); - Some((source_buffer, selection_range)) + if first_selection.is_empty() { + let full_range = Point::new(0, 0)..max_point; + return Some((source_buffer, full_range)); + } + + let start = first_selection.start; + let end = first_selection.end; + let expanded_start = Point::new(start.row, 0); + + let expanded_end = if end.column > 0 { + let next_row = end.row + 1; + cmp::min(max_point, Point::new(next_row, 0)) + } else { + end + }; + Some((source_buffer, expanded_start..expanded_end)) }); - let Some((source_buffer, selected_range)) = source_editor_buffer_and_range else { + let Some((source_buffer, expanded_selection_range)) = selection_data else { log::warn!("There should always be at least one selection in Zed. This is a bug."); return None; }; - let clipboard_text = diff_data.clipboard_text.clone(); - - let workspace = workspace.weak_handle(); - - let diff_buffer = cx.new(|cx| { - let source_buffer_snapshot = source_buffer.read(cx).snapshot(); - let diff = BufferDiff::new(&source_buffer_snapshot.text, cx); - diff + source_editor.update(cx, |source_editor, cx| { + source_editor.change_selections(Default::default(), window, cx, |s| { + s.select_ranges(vec![ + expanded_selection_range.start..expanded_selection_range.end, + ]); + }) }); - let clipboard_buffer = - build_clipboard_buffer(clipboard_text, &source_buffer, selected_range.clone(), cx); + let source_buffer_snapshot = source_buffer.read(cx).snapshot(); + let mut clipboard_text = diff_data.clipboard_text.clone(); + + if !clipboard_text.ends_with("\n") { + clipboard_text.push_str("\n"); + } + + let workspace = workspace.weak_handle(); + let diff_buffer = cx.new(|cx| BufferDiff::new(&source_buffer_snapshot.text, cx)); + let clipboard_buffer = build_clipboard_buffer( + clipboard_text, + &source_buffer, + expanded_selection_range.clone(), + cx, + ); let task = window.spawn(cx, async move |cx| { let project = workspace.update(cx, |workspace, _| workspace.project().clone())?; @@ -89,7 +112,7 @@ impl TextDiffView { clipboard_buffer, source_editor, source_buffer, - selected_range, + expanded_selection_range, diff_buffer, project, window, @@ -208,9 +231,9 @@ impl TextDiffView { } fn build_clipboard_buffer( - clipboard_text: String, + text: String, source_buffer: &Entity, - selected_range: Range, + replacement_range: Range, cx: &mut App, ) -> Entity { let source_buffer_snapshot = source_buffer.read(cx).snapshot(); @@ -219,9 +242,9 @@ fn build_clipboard_buffer( let language = source_buffer.read(cx).language().cloned(); buffer.set_language(language, cx); - let range_start = source_buffer_snapshot.point_to_offset(selected_range.start); - let range_end = source_buffer_snapshot.point_to_offset(selected_range.end); - buffer.edit([(range_start..range_end, clipboard_text)], None, cx); + let range_start = source_buffer_snapshot.point_to_offset(replacement_range.start); + let range_end = source_buffer_snapshot.point_to_offset(replacement_range.end); + buffer.edit([(range_start..range_end, text)], None, cx); buffer }) @@ -395,21 +418,13 @@ pub fn selection_location_text(editor: &Editor, cx: &App) -> Option { let buffer_snapshot = buffer.snapshot(cx); let first_selection = editor.selections.disjoint.first()?; - let (start_row, start_column, end_row, end_column) = - if first_selection.start == first_selection.end { - let max_point = buffer_snapshot.max_point(); - (0, 0, max_point.row, max_point.column) - } else { - let selection_start = first_selection.start.to_point(&buffer_snapshot); - let selection_end = first_selection.end.to_point(&buffer_snapshot); + let selection_start = first_selection.start.to_point(&buffer_snapshot); + let selection_end = first_selection.end.to_point(&buffer_snapshot); - ( - selection_start.row, - selection_start.column, - selection_end.row, - selection_end.column, - ) - }; + let start_row = selection_start.row; + let start_column = selection_start.column; + let end_row = selection_end.row; + let end_column = selection_end.column; let range_text = if start_row == end_row { format!("L{}:{}-{}", start_row + 1, start_column + 1, end_column + 1) @@ -435,14 +450,13 @@ impl Render for TextDiffView { #[cfg(test)] mod tests { use super::*; - - use editor::{actions, test::editor_test_context::assert_state_with_diff}; + use editor::test::editor_test_context::assert_state_with_diff; use gpui::{TestAppContext, VisualContext}; use project::{FakeFs, Project}; use serde_json::json; use settings::{Settings, SettingsStore}; use unindent::unindent; - use util::path; + use util::{path, test::marked_text_ranges}; fn init_test(cx: &mut TestAppContext) { cx.update(|cx| { @@ -457,52 +471,236 @@ mod tests { } #[gpui::test] - async fn test_diffing_clipboard_against_specific_selection(cx: &mut TestAppContext) { - base_test(true, cx).await; + async fn test_diffing_clipboard_against_empty_selection_uses_full_buffer_selection( + cx: &mut TestAppContext, + ) { + base_test( + path!("/test"), + path!("/test/text.txt"), + "def process_incoming_inventory(items, warehouse_id):\n pass\n", + "def process_outgoing_inventory(items, warehouse_id):\n passˇ\n", + &unindent( + " + - def process_incoming_inventory(items, warehouse_id): + + ˇdef process_outgoing_inventory(items, warehouse_id): + pass + ", + ), + "Clipboard ↔ text.txt @ L1:1-L3:1", + &format!("Clipboard ↔ {} @ L1:1-L3:1", path!("test/text.txt")), + cx, + ) + .await; } #[gpui::test] - async fn test_diffing_clipboard_against_empty_selection_uses_full_buffer( + async fn test_diffing_clipboard_against_multiline_selection_expands_to_full_lines( cx: &mut TestAppContext, ) { - base_test(false, cx).await; + base_test( + path!("/test"), + path!("/test/text.txt"), + "def process_incoming_inventory(items, warehouse_id):\n pass\n", + "«def process_outgoing_inventory(items, warehouse_id):\n passˇ»\n", + &unindent( + " + - def process_incoming_inventory(items, warehouse_id): + + ˇdef process_outgoing_inventory(items, warehouse_id): + pass + ", + ), + "Clipboard ↔ text.txt @ L1:1-L3:1", + &format!("Clipboard ↔ {} @ L1:1-L3:1", path!("test/text.txt")), + cx, + ) + .await; } - async fn base_test(select_all_text: bool, cx: &mut TestAppContext) { + #[gpui::test] + async fn test_diffing_clipboard_against_single_line_selection(cx: &mut TestAppContext) { + base_test( + path!("/test"), + path!("/test/text.txt"), + "a", + "«bbˇ»", + &unindent( + " + - a + + ˇbb", + ), + "Clipboard ↔ text.txt @ L1:1-3", + &format!("Clipboard ↔ {} @ L1:1-3", path!("test/text.txt")), + cx, + ) + .await; + } + + #[gpui::test] + async fn test_diffing_clipboard_with_leading_whitespace_against_line(cx: &mut TestAppContext) { + base_test( + path!("/test"), + path!("/test/text.txt"), + " a", + "«bbˇ»", + &unindent( + " + - a + + ˇbb", + ), + "Clipboard ↔ text.txt @ L1:1-3", + &format!("Clipboard ↔ {} @ L1:1-3", path!("test/text.txt")), + cx, + ) + .await; + } + + #[gpui::test] + async fn test_diffing_clipboard_against_line_with_leading_whitespace(cx: &mut TestAppContext) { + base_test( + path!("/test"), + path!("/test/text.txt"), + "a", + " «bbˇ»", + &unindent( + " + - a + + ˇ bb", + ), + "Clipboard ↔ text.txt @ L1:1-7", + &format!("Clipboard ↔ {} @ L1:1-7", path!("test/text.txt")), + cx, + ) + .await; + } + + #[gpui::test] + async fn test_diffing_clipboard_against_line_with_leading_whitespace_included_in_selection( + cx: &mut TestAppContext, + ) { + base_test( + path!("/test"), + path!("/test/text.txt"), + "a", + "« bbˇ»", + &unindent( + " + - a + + ˇ bb", + ), + "Clipboard ↔ text.txt @ L1:1-7", + &format!("Clipboard ↔ {} @ L1:1-7", path!("test/text.txt")), + cx, + ) + .await; + } + + #[gpui::test] + async fn test_diffing_clipboard_with_leading_whitespace_against_line_with_leading_whitespace( + cx: &mut TestAppContext, + ) { + base_test( + path!("/test"), + path!("/test/text.txt"), + " a", + " «bbˇ»", + &unindent( + " + - a + + ˇ bb", + ), + "Clipboard ↔ text.txt @ L1:1-7", + &format!("Clipboard ↔ {} @ L1:1-7", path!("test/text.txt")), + cx, + ) + .await; + } + + #[gpui::test] + async fn test_diffing_clipboard_with_leading_whitespace_against_line_with_leading_whitespace_included_in_selection( + cx: &mut TestAppContext, + ) { + base_test( + path!("/test"), + path!("/test/text.txt"), + " a", + "« bbˇ»", + &unindent( + " + - a + + ˇ bb", + ), + "Clipboard ↔ text.txt @ L1:1-7", + &format!("Clipboard ↔ {} @ L1:1-7", path!("test/text.txt")), + cx, + ) + .await; + } + + #[gpui::test] + async fn test_diffing_clipboard_against_partial_selection_expands_to_include_trailing_characters( + cx: &mut TestAppContext, + ) { + base_test( + path!("/test"), + path!("/test/text.txt"), + "a", + "«bˇ»b", + &unindent( + " + - a + + ˇbb", + ), + "Clipboard ↔ text.txt @ L1:1-3", + &format!("Clipboard ↔ {} @ L1:1-3", path!("test/text.txt")), + cx, + ) + .await; + } + + async fn base_test( + project_root: &str, + file_path: &str, + clipboard_text: &str, + editor_text: &str, + expected_diff: &str, + expected_tab_title: &str, + expected_tab_tooltip: &str, + cx: &mut TestAppContext, + ) { init_test(cx); + let file_name = std::path::Path::new(file_path) + .file_name() + .unwrap() + .to_str() + .unwrap(); + let fs = FakeFs::new(cx.executor()); fs.insert_tree( - path!("/test"), + project_root, json!({ - "a": { - "b": { - "text.txt": "new line 1\nline 2\nnew line 3\nline 4" - } - } + file_name: editor_text }), ) .await; - let project = Project::test(fs, [path!("/test").as_ref()], cx).await; + let project = Project::test(fs, [project_root.as_ref()], cx).await; let (workspace, mut cx) = cx.add_window_view(|window, cx| Workspace::test_new(project.clone(), window, cx)); let buffer = project - .update(cx, |project, cx| { - project.open_local_buffer(path!("/test/a/b/text.txt"), cx) - }) + .update(cx, |project, cx| project.open_local_buffer(file_path, cx)) .await .unwrap(); let editor = cx.new_window_entity(|window, cx| { let mut editor = Editor::for_buffer(buffer, None, window, cx); - editor.set_text("new line 1\nline 2\nnew line 3\nline 4\n", window, cx); - - if select_all_text { - editor.select_all(&actions::SelectAll, window, cx); - } + let (unmarked_text, selection_ranges) = marked_text_ranges(editor_text, false); + editor.set_text(unmarked_text, window, cx); + editor.change_selections(Default::default(), window, cx, |s| { + s.select_ranges(selection_ranges) + }); editor }); @@ -511,7 +709,7 @@ mod tests { .update_in(cx, |workspace, window, cx| { TextDiffView::open( &DiffClipboardWithSelectionData { - clipboard_text: "old line 1\nline 2\nold line 3\nline 4\n".to_string(), + clipboard_text: clipboard_text.to_string(), editor, }, workspace, @@ -528,26 +726,14 @@ mod tests { assert_state_with_diff( &diff_view.read_with(cx, |diff_view, _| diff_view.diff_editor.clone()), &mut cx, - &unindent( - " - - old line 1 - + ˇnew line 1 - line 2 - - old line 3 - + new line 3 - line 4 - ", - ), + expected_diff, ); diff_view.read_with(cx, |diff_view, cx| { - assert_eq!( - diff_view.tab_content_text(0, cx), - "Clipboard ↔ text.txt @ L1:1-L5:1" - ); + assert_eq!(diff_view.tab_content_text(0, cx), expected_tab_title); assert_eq!( diff_view.tab_tooltip_text(cx).unwrap(), - format!("Clipboard ↔ {}", path!("test/a/b/text.txt @ L1:1-L5:1")) + expected_tab_tooltip ); }); } From 65759d43163bd36cce8f8aa492ba2628ca005a7a Mon Sep 17 00:00:00 2001 From: Jason Lee Date: Thu, 24 Jul 2025 16:27:29 +0800 Subject: [PATCH 021/893] gpui: Fix Interactivity prepaint to update scroll_handle bounds (#35013) It took a long time to check this problem. Finally, I found that due to a detail missing when changing #34832, the bounds of `ScrollHandle` was not updated in the Interactivity `prepaint` phase. ```diff - scroll_handle_state.padded_content_size = padded_content_size; + scroll_handle_state.max_offset = scroll_max; ``` It was correct before the change, because the `padded_content_size` (including `bounds.size`) was saved before, and the bounds was missing after changing to `max_offset`, but the bounds were not updated anywhere. So when `scroll_handle.bounds()` is obtained outside, it is always 0px here. @MrSubidubi Release Notes: - N/A --- crates/gpui/src/elements/div.rs | 7 +------ crates/gpui/src/elements/uniform_list.rs | 5 ++--- 2 files changed, 3 insertions(+), 9 deletions(-) diff --git a/crates/gpui/src/elements/div.rs b/crates/gpui/src/elements/div.rs index 4655c92409..fa47758581 100644 --- a/crates/gpui/src/elements/div.rs +++ b/crates/gpui/src/elements/div.rs @@ -1334,7 +1334,6 @@ impl Element for Div { } else if let Some(scroll_handle) = self.interactivity.tracked_scroll_handle.as_ref() { let mut state = scroll_handle.0.borrow_mut(); state.child_bounds = Vec::with_capacity(request_layout.child_layout_ids.len()); - state.bounds = bounds; for child_layout_id in &request_layout.child_layout_ids { let child_bounds = window.layout_bounds(*child_layout_id); child_min = child_min.min(&child_bounds.origin); @@ -1706,6 +1705,7 @@ impl Interactivity { if let Some(mut scroll_handle_state) = tracked_scroll_handle { scroll_handle_state.max_offset = scroll_max; + scroll_handle_state.bounds = bounds; } *scroll_offset @@ -3007,11 +3007,6 @@ impl ScrollHandle { self.0.borrow().bounds } - /// Set the bounds into which this child is painted - pub(super) fn set_bounds(&self, bounds: Bounds) { - self.0.borrow_mut().bounds = bounds; - } - /// Get the bounds for a specific child. pub fn bounds_for_item(&self, ix: usize) -> Option> { self.0.borrow().child_bounds.get(ix).cloned() diff --git a/crates/gpui/src/elements/uniform_list.rs b/crates/gpui/src/elements/uniform_list.rs index 52e2015c20..e80656a078 100644 --- a/crates/gpui/src/elements/uniform_list.rs +++ b/crates/gpui/src/elements/uniform_list.rs @@ -295,9 +295,8 @@ impl Element for UniformList { bounds.bottom_right() - point(border.right + padding.right, border.bottom), ); - let y_flipped = if let Some(scroll_handle) = self.scroll_handle.as_mut() { - let mut scroll_state = scroll_handle.0.borrow_mut(); - scroll_state.base_handle.set_bounds(bounds); + let y_flipped = if let Some(scroll_handle) = &self.scroll_handle { + let scroll_state = scroll_handle.0.borrow(); scroll_state.y_flipped } else { false From cd9bcc7f0963c7dd06c6623fce039e18b42f682e Mon Sep 17 00:00:00 2001 From: Finn Evers Date: Thu, 24 Jul 2025 10:40:36 +0200 Subject: [PATCH 022/893] agent_ui: Improve wrapping behavior in provider configuration header (#34989) This ensures that the "Add provider" button does not move offscreen too fast and ensures the text wraps for smaller panel sizes. | Before | After | | --- | --- | | image | image | Release Notes: - N/A --- crates/agent_ui/src/agent_configuration.rs | 86 +++++++++++++--------- 1 file changed, 51 insertions(+), 35 deletions(-) diff --git a/crates/agent_ui/src/agent_configuration.rs b/crates/agent_ui/src/agent_configuration.rs index 7a160a5649..1870c3e3d2 100644 --- a/crates/agent_ui/src/agent_configuration.rs +++ b/crates/agent_ui/src/agent_configuration.rs @@ -321,46 +321,62 @@ impl AgentConfiguration { .justify_between() .child( v_flex() + .w_full() .gap_0p5() - .child(Headline::new("LLM Providers")) + .child( + h_flex() + .w_full() + .gap_2() + .justify_between() + .child(Headline::new("LLM Providers")) + .child( + PopoverMenu::new("add-provider-popover") + .trigger( + Button::new("add-provider", "Add Provider") + .icon_position(IconPosition::Start) + .icon(IconName::Plus) + .icon_size(IconSize::Small) + .icon_color(Color::Muted) + .label_size(LabelSize::Small), + ) + .anchor(gpui::Corner::TopRight) + .menu({ + let workspace = self.workspace.clone(); + move |window, cx| { + Some(ContextMenu::build( + window, + cx, + |menu, _window, _cx| { + menu.header("Compatible APIs").entry( + "OpenAI", + None, + { + let workspace = + workspace.clone(); + move |window, cx| { + workspace + .update(cx, |workspace, cx| { + AddLlmProviderModal::toggle( + LlmCompatibleProvider::OpenAi, + workspace, + window, + cx, + ); + }) + .log_err(); + } + }, + ) + }, + )) + } + }), + ), + ) .child( Label::new("Add at least one provider to use AI-powered features.") .color(Color::Muted), ), - ) - .child( - PopoverMenu::new("add-provider-popover") - .trigger( - Button::new("add-provider", "Add Provider") - .icon_position(IconPosition::Start) - .icon(IconName::Plus) - .icon_size(IconSize::Small) - .icon_color(Color::Muted) - .label_size(LabelSize::Small), - ) - .anchor(gpui::Corner::TopRight) - .menu({ - let workspace = self.workspace.clone(); - move |window, cx| { - Some(ContextMenu::build(window, cx, |menu, _window, _cx| { - menu.header("Compatible APIs").entry("OpenAI", None, { - let workspace = workspace.clone(); - move |window, cx| { - workspace - .update(cx, |workspace, cx| { - AddLlmProviderModal::toggle( - LlmCompatibleProvider::OpenAi, - workspace, - window, - cx, - ); - }) - .log_err(); - } - }) - })) - } - }), ), ) .child( From 5c9363b1c47426e9f65858f7dbc2e6af42bbe403 Mon Sep 17 00:00:00 2001 From: "Joseph T. Lyons" Date: Thu, 24 Jul 2025 04:43:28 -0400 Subject: [PATCH 023/893] Differentiate between file and selection diff events (#35014) Release Notes: - N/A --- crates/git_ui/src/text_diff_view.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/git_ui/src/text_diff_view.rs b/crates/git_ui/src/text_diff_view.rs index be1866a354..005c1e18b4 100644 --- a/crates/git_ui/src/text_diff_view.rs +++ b/crates/git_ui/src/text_diff_view.rs @@ -316,7 +316,7 @@ impl Item for TextDiffView { } fn telemetry_event_text(&self) -> Option<&'static str> { - Some("Diff View Opened") + Some("Selection Diff View Opened") } fn deactivated(&mut self, window: &mut Window, cx: &mut Context) { From 913b9296d755d88a85ac6fad2d57f6c1e5d7cef6 Mon Sep 17 00:00:00 2001 From: "Joseph T. Lyons" Date: Thu, 24 Jul 2025 04:49:04 -0400 Subject: [PATCH 024/893] Add `editor: convert to sentence case` (#35015) This PR adds an `editor: convert to sentence case` action. I frequently find myself copying branch names and then removing the hyphens and ensuring the first letter is capitalized, and then using the result text for the commit message. For example: image You can achieve this with a combination of other text manipulation commands, but this action makes it even easier. Also, moved `toggle_case` down into the area where all other commands internally using `manipulate_text` are located. Release Notes: - Added `editor: convert to sentence case` --- crates/editor/src/actions.rs | 2 ++ crates/editor/src/editor.rs | 31 ++++++++++++++++++++----------- crates/editor/src/editor_tests.rs | 17 +++++++++++++++++ crates/editor/src/element.rs | 3 ++- 4 files changed, 41 insertions(+), 12 deletions(-) diff --git a/crates/editor/src/actions.rs b/crates/editor/src/actions.rs index f80a6afbbb..1212651cb3 100644 --- a/crates/editor/src/actions.rs +++ b/crates/editor/src/actions.rs @@ -365,6 +365,8 @@ actions!( ConvertToLowerCase, /// Toggles the case of selected text. ConvertToOppositeCase, + /// Converts selected text to sentence case. + ConvertToSentenceCase, /// Converts selected text to snake_case. ConvertToSnakeCase, /// Converts selected text to Title Case. diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs index 069d8cffb3..8f57fb1a20 100644 --- a/crates/editor/src/editor.rs +++ b/crates/editor/src/editor.rs @@ -10878,17 +10878,6 @@ impl Editor { }); } - pub fn toggle_case(&mut self, _: &ToggleCase, window: &mut Window, cx: &mut Context) { - self.manipulate_text(window, cx, |text| { - let has_upper_case_characters = text.chars().any(|c| c.is_uppercase()); - if has_upper_case_characters { - text.to_lowercase() - } else { - text.to_uppercase() - } - }) - } - fn manipulate_immutable_lines( &mut self, window: &mut Window, @@ -11144,6 +11133,26 @@ impl Editor { }) } + pub fn convert_to_sentence_case( + &mut self, + _: &ConvertToSentenceCase, + window: &mut Window, + cx: &mut Context, + ) { + self.manipulate_text(window, cx, |text| text.to_case(Case::Sentence)) + } + + pub fn toggle_case(&mut self, _: &ToggleCase, window: &mut Window, cx: &mut Context) { + self.manipulate_text(window, cx, |text| { + let has_upper_case_characters = text.chars().any(|c| c.is_uppercase()); + if has_upper_case_characters { + text.to_lowercase() + } else { + text.to_uppercase() + } + }) + } + pub fn convert_to_rot13( &mut self, _: &ConvertToRot13, diff --git a/crates/editor/src/editor_tests.rs b/crates/editor/src/editor_tests.rs index 8d121972d0..03b047e92e 100644 --- a/crates/editor/src/editor_tests.rs +++ b/crates/editor/src/editor_tests.rs @@ -4724,6 +4724,23 @@ async fn test_toggle_case(cx: &mut TestAppContext) { "}); } +#[gpui::test] +async fn test_convert_to_sentence_case(cx: &mut TestAppContext) { + init_test(cx, |_| {}); + + let mut cx = EditorTestContext::new(cx).await; + + cx.set_state(indoc! {" + «implement-windows-supportˇ» + "}); + cx.update_editor(|e, window, cx| { + e.convert_to_sentence_case(&ConvertToSentenceCase, window, cx) + }); + cx.assert_editor_state(indoc! {" + «Implement windows supportˇ» + "}); +} + #[gpui::test] async fn test_manipulate_text(cx: &mut TestAppContext) { init_test(cx, |_| {}); diff --git a/crates/editor/src/element.rs b/crates/editor/src/element.rs index d2ee9d6b0a..5fd6b028f4 100644 --- a/crates/editor/src/element.rs +++ b/crates/editor/src/element.rs @@ -230,7 +230,6 @@ impl EditorElement { register_action(editor, window, Editor::sort_lines_case_insensitive); register_action(editor, window, Editor::reverse_lines); register_action(editor, window, Editor::shuffle_lines); - register_action(editor, window, Editor::toggle_case); register_action(editor, window, Editor::convert_indentation_to_spaces); register_action(editor, window, Editor::convert_indentation_to_tabs); register_action(editor, window, Editor::convert_to_upper_case); @@ -241,6 +240,8 @@ impl EditorElement { register_action(editor, window, Editor::convert_to_upper_camel_case); register_action(editor, window, Editor::convert_to_lower_camel_case); register_action(editor, window, Editor::convert_to_opposite_case); + register_action(editor, window, Editor::convert_to_sentence_case); + register_action(editor, window, Editor::toggle_case); register_action(editor, window, Editor::convert_to_rot13); register_action(editor, window, Editor::convert_to_rot47); register_action(editor, window, Editor::delete_to_previous_word_start); From dd52fb58feddd1d6200bc40c641e9189836ad753 Mon Sep 17 00:00:00 2001 From: Finn Evers Date: Thu, 24 Jul 2025 10:51:40 +0200 Subject: [PATCH 025/893] terminal_view: Ensure breadcrumbs are updated on settings change (#35016) Currently, terminal breadcrumbs are only updated after a settings change once the terminal view is focused again. This change ensures that the breadcrumbs are updated instantaneously once the breadcrumb settings changes. Release Notes: - Fixed an issue where terminal breadcrumbs would not react instantly to settings changes. --- crates/terminal_view/src/terminal_view.rs | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/crates/terminal_view/src/terminal_view.rs b/crates/terminal_view/src/terminal_view.rs index 1cc1fbcf6f..bf65a736e8 100644 --- a/crates/terminal_view/src/terminal_view.rs +++ b/crates/terminal_view/src/terminal_view.rs @@ -430,6 +430,7 @@ impl TerminalView { fn settings_changed(&mut self, cx: &mut Context) { let settings = TerminalSettings::get_global(cx); + let breadcrumb_visibility_changed = self.show_breadcrumbs != settings.toolbar.breadcrumbs; self.show_breadcrumbs = settings.toolbar.breadcrumbs; let new_cursor_shape = settings.cursor_shape.unwrap_or_default(); @@ -441,6 +442,9 @@ impl TerminalView { }); } + if breadcrumb_visibility_changed { + cx.emit(ItemEvent::UpdateBreadcrumbs); + } cx.notify(); } From 0af690080bc4353d71d1039374e5cbbfce656718 Mon Sep 17 00:00:00 2001 From: Oleksiy Syvokon Date: Thu, 24 Jul 2025 15:22:57 +0300 Subject: [PATCH 026/893] linux: Fix `ctrl-0..9`, `ctrl-[`, `ctrl-^` (#35028) There were two different underlying reasons for the issues with ctrl-number and ctrl-punctuation: 1. Some keys in the ctrl-0..9 range send codes in the `\1b`..`\1f` range. For example, `ctrl-2` sends keycode for `ctrl-[` (0x1b), but we want to map it to `2`, not to `[`. 2. `ctrl-[` and four other ctrl-punctuation were incorrectly mapped, since the expected conversion is by adding 0x40 Closes #35012 Release Notes: - N/A --- crates/gpui/src/platform/linux/platform.rs | 12 +++++++++--- 1 file changed, 9 insertions(+), 3 deletions(-) diff --git a/crates/gpui/src/platform/linux/platform.rs b/crates/gpui/src/platform/linux/platform.rs index d65118e994..fe6a36baa8 100644 --- a/crates/gpui/src/platform/linux/platform.rs +++ b/crates/gpui/src/platform/linux/platform.rs @@ -845,9 +845,15 @@ impl crate::Keystroke { { if key.is_ascii_graphic() { key_utf8.to_lowercase() - // map ctrl-a to a - } else if key_utf32 <= 0x1f { - ((key_utf32 as u8 + 0x60) as char).to_string() + // map ctrl-a to `a` + // ctrl-0..9 may emit control codes like ctrl-[, but + // we don't want to map them to `[` + } else if key_utf32 <= 0x1f + && !name.chars().next().is_some_and(|c| c.is_ascii_digit()) + { + ((key_utf32 as u8 + 0x40) as char) + .to_ascii_lowercase() + .to_string() } else { name } From 1e2b0fcab6535f53857f401ba7ef2435c40b7e1e Mon Sep 17 00:00:00 2001 From: Piotr Osiewicz <24362066+osiewicz@users.noreply.github.com> Date: Thu, 24 Jul 2025 14:30:49 +0200 Subject: [PATCH 027/893] sum_tree: Remove Unit type (#35027) This solves one ~TODO, as Unit type was a workaround for a lack of ability to implement Summary for (). Release Notes: - N/A --- crates/sum_tree/src/sum_tree.rs | 12 +++++------- crates/worktree/src/worktree.rs | 14 ++++---------- 2 files changed, 9 insertions(+), 17 deletions(-) diff --git a/crates/sum_tree/src/sum_tree.rs b/crates/sum_tree/src/sum_tree.rs index 4f9e01ce20..4c5ce39590 100644 --- a/crates/sum_tree/src/sum_tree.rs +++ b/crates/sum_tree/src/sum_tree.rs @@ -41,16 +41,14 @@ pub trait Summary: Clone { fn add_summary(&mut self, summary: &Self, cx: &Self::Context); } -/// This type exists because we can't implement Summary for () without causing -/// type resolution errors -#[derive(Copy, Clone, PartialEq, Eq, Debug)] -pub struct Unit; - -impl Summary for Unit { +/// Catch-all implementation for when you need something that implements [`Summary`] without a specific type. +/// We implement it on a &'static, as that avoids blanket impl collisions with `impl Dimension for T` +/// (as we also need unit type to be a fill-in dimension) +impl Summary for &'static () { type Context = (); fn zero(_: &()) -> Self { - Unit + &() } fn add_summary(&mut self, _: &Self, _: &()) {} diff --git a/crates/worktree/src/worktree.rs b/crates/worktree/src/worktree.rs index 4fc6b91abb..e6949f62df 100644 --- a/crates/worktree/src/worktree.rs +++ b/crates/worktree/src/worktree.rs @@ -62,7 +62,7 @@ use std::{ }, time::{Duration, Instant}, }; -use sum_tree::{Bias, Edit, KeyedItem, SeekTarget, SumTree, Summary, TreeMap, TreeSet, Unit}; +use sum_tree::{Bias, Edit, KeyedItem, SeekTarget, SumTree, Summary, TreeMap, TreeSet}; use text::{LineEnding, Rope}; use util::{ ResultExt, @@ -407,12 +407,12 @@ struct LocalRepositoryEntry { } impl sum_tree::Item for LocalRepositoryEntry { - type Summary = PathSummary; + type Summary = PathSummary<&'static ()>; fn summary(&self, _: &::Context) -> Self::Summary { PathSummary { max_path: self.work_directory.path_key().0, - item_summary: Unit, + item_summary: &(), } } } @@ -425,12 +425,6 @@ impl KeyedItem for LocalRepositoryEntry { } } -//impl LocalRepositoryEntry { -// pub fn repo(&self) -> &Arc { -// &self.repo_ptr -// } -//} - impl Deref for LocalRepositoryEntry { type Target = WorkDirectory; @@ -5417,7 +5411,7 @@ impl<'a> SeekTarget<'a, EntrySummary, TraversalProgress<'a>> for TraversalTarget } } -impl<'a> SeekTarget<'a, PathSummary, TraversalProgress<'a>> for TraversalTarget<'_> { +impl<'a> SeekTarget<'a, PathSummary<&'static ()>, TraversalProgress<'a>> for TraversalTarget<'_> { fn cmp(&self, cursor_location: &TraversalProgress<'a>, _: &()) -> Ordering { self.cmp_progress(cursor_location) } From 4fb540d6d2adb58b2e61ab1bdfa7c820eb9798d8 Mon Sep 17 00:00:00 2001 From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com> Date: Thu, 24 Jul 2025 09:39:10 -0300 Subject: [PATCH 028/893] dock: Add divider between panels on the right side, too (#35003) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit A while ago, we added a divider in the left side of the status bar between the icon buttons that open panels vs. those that open something else (tabs, popover menus, etc.). There isn't a super good reason why we wouldn't do the same in the right side, even more so given that (at least by default) we usually have more buttons on that side; buttons that _don't_ open panels (regardless of being docked to the bottom or right). So, this PR does this! CleanShot 2025-07-24 at 1  59 10@2x Release Notes: - N/A --- crates/workspace/src/dock.rs | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/crates/workspace/src/dock.rs b/crates/workspace/src/dock.rs index 7165de23ec..ca63d3e553 100644 --- a/crates/workspace/src/dock.rs +++ b/crates/workspace/src/dock.rs @@ -934,6 +934,10 @@ impl Render for PanelButtons { h_flex() .gap_1() + .when( + has_buttons && dock.position == DockPosition::Bottom, + |this| this.child(Divider::vertical().color(DividerColor::Border)), + ) .children(buttons) .when(has_buttons && dock.position == DockPosition::Left, |this| { this.child(Divider::vertical().color(DividerColor::Border)) From fab450e39d39364ff6e2f08121c6d31e301a47ca Mon Sep 17 00:00:00 2001 From: Peter Tripp Date: Thu, 24 Jul 2025 09:20:25 -0400 Subject: [PATCH 029/893] Fix invalid regular expressions highlighting all search fields (#35001) Closes https://github.com/zed-industries/zed/issues/34969 Closes https://github.com/zed-industries/zed/issues/34970 Only highlight the search field on regex error (buffer search and project search). Clear errors when the buffer search hidden so stale errors aren't shown on next search. Before (all fields highlighted red): Screenshot 2025-07-23 at 22 59 45 After (only query field highlighted red): Screenshot 2025-07-23 at 23 10 49 Release Notes: - Improved highlighting of regex errors in search dialogs --- crates/search/src/buffer_search.rs | 22 +++++++++++++--------- crates/search/src/project_search.rs | 13 +++++++------ 2 files changed, 20 insertions(+), 15 deletions(-) diff --git a/crates/search/src/buffer_search.rs b/crates/search/src/buffer_search.rs index 91b7fe488e..5d77a95027 100644 --- a/crates/search/src/buffer_search.rs +++ b/crates/search/src/buffer_search.rs @@ -228,16 +228,17 @@ impl Render for BufferSearchBar { if in_replace { key_context.add("in_replace"); } - let editor_border = if self.query_error.is_some() { + let query_border = if self.query_error.is_some() { Color::Error.color(cx) } else { cx.theme().colors().border }; + let replacement_border = cx.theme().colors().border; let container_width = window.viewport_size().width; let input_width = SearchInputWidth::calc_width(container_width); - let input_base_styles = || { + let input_base_styles = |border_color| { h_flex() .min_w_32() .w(input_width) @@ -246,7 +247,7 @@ impl Render for BufferSearchBar { .pr_1() .py_1() .border_1() - .border_color(editor_border) + .border_color(border_color) .rounded_lg() }; @@ -256,7 +257,7 @@ impl Render for BufferSearchBar { el.child(Label::new("Find in results").color(Color::Hint)) }) .child( - input_base_styles() + input_base_styles(query_border) .id("editor-scroll") .track_scroll(&self.editor_scroll_handle) .child(self.render_text_input(&self.query_editor, color_override, cx)) @@ -430,11 +431,13 @@ impl Render for BufferSearchBar { let replace_line = should_show_replace_input.then(|| { h_flex() .gap_2() - .child(input_base_styles().child(self.render_text_input( - &self.replacement_editor, - None, - cx, - ))) + .child( + input_base_styles(replacement_border).child(self.render_text_input( + &self.replacement_editor, + None, + cx, + )), + ) .child( h_flex() .min_w_64() @@ -775,6 +778,7 @@ impl BufferSearchBar { pub fn dismiss(&mut self, _: &Dismiss, window: &mut Window, cx: &mut Context) { self.dismissed = true; + self.query_error = None; for searchable_item in self.searchable_items_with_matches.keys() { if let Some(searchable_item) = WeakSearchableItemHandle::upgrade(searchable_item.as_ref(), cx) diff --git a/crates/search/src/project_search.rs b/crates/search/src/project_search.rs index 57ca5e56b9..3b9700c5f1 100644 --- a/crates/search/src/project_search.rs +++ b/crates/search/src/project_search.rs @@ -195,6 +195,7 @@ pub struct ProjectSearch { #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] enum InputPanel { Query, + Replacement, Exclude, Include, } @@ -1962,7 +1963,7 @@ impl Render for ProjectSearchBar { MultipleInputs, } - let input_base_styles = |base_style: BaseStyle| { + let input_base_styles = |base_style: BaseStyle, panel: InputPanel| { h_flex() .min_w_32() .map(|div| match base_style { @@ -1974,11 +1975,11 @@ impl Render for ProjectSearchBar { .pr_1() .py_1() .border_1() - .border_color(search.border_color_for(InputPanel::Query, cx)) + .border_color(search.border_color_for(panel, cx)) .rounded_lg() }; - let query_column = input_base_styles(BaseStyle::SingleInput) + let query_column = input_base_styles(BaseStyle::SingleInput, InputPanel::Query) .on_action(cx.listener(|this, action, window, cx| this.confirm(action, window, cx))) .on_action(cx.listener(|this, action, window, cx| { this.previous_history_query(action, window, cx) @@ -2167,7 +2168,7 @@ impl Render for ProjectSearchBar { .child(h_flex().min_w_64().child(mode_column).child(matches_column)); let replace_line = search.replace_enabled.then(|| { - let replace_column = input_base_styles(BaseStyle::SingleInput) + let replace_column = input_base_styles(BaseStyle::SingleInput, InputPanel::Replacement) .child(self.render_text_input(&search.replacement_editor, cx)); let focus_handle = search.replacement_editor.read(cx).focus_handle(cx); @@ -2241,7 +2242,7 @@ impl Render for ProjectSearchBar { .gap_2() .w(input_width) .child( - input_base_styles(BaseStyle::MultipleInputs) + input_base_styles(BaseStyle::MultipleInputs, InputPanel::Include) .on_action(cx.listener(|this, action, window, cx| { this.previous_history_query(action, window, cx) })) @@ -2251,7 +2252,7 @@ impl Render for ProjectSearchBar { .child(self.render_text_input(&search.included_files_editor, cx)), ) .child( - input_base_styles(BaseStyle::MultipleInputs) + input_base_styles(BaseStyle::MultipleInputs, InputPanel::Exclude) .on_action(cx.listener(|this, action, window, cx| { this.previous_history_query(action, window, cx) })) From 29332c1962809b0cf812df5c444324e854c62011 Mon Sep 17 00:00:00 2001 From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com> Date: Thu, 24 Jul 2025 11:26:15 -0300 Subject: [PATCH 030/893] ai onboarding: Add overall fixes to the whole flow (#34996) Closes https://github.com/zed-industries/zed/issues/34979 Release Notes: - N/A --------- Co-authored-by: Agus Zubiaga Co-authored-by: Ben Kunkle --- crates/agent/src/thread_store.rs | 9 +- crates/agent_ui/src/agent_configuration.rs | 11 +- crates/agent_ui/src/agent_panel.rs | 56 +++--- crates/agent_ui/src/message_editor.rs | 52 +++--- crates/agent_ui/src/ui.rs | 1 - crates/agent_ui/src/ui/end_trial_upsell.rs | 55 +++--- crates/agent_ui/src/ui/upsell.rs | 163 ------------------ .../src/agent_panel_onboarding_content.rs | 7 +- crates/ai_onboarding/src/ai_onboarding.rs | 30 +++- crates/assistant_context/src/context_store.rs | 5 + crates/client/src/user.rs | 6 +- crates/language_models/src/provider/cloud.rs | 5 +- 12 files changed, 150 insertions(+), 250 deletions(-) delete mode 100644 crates/agent_ui/src/ui/upsell.rs diff --git a/crates/agent/src/thread_store.rs b/crates/agent/src/thread_store.rs index 0347156cd4..cc7cb50c91 100644 --- a/crates/agent/src/thread_store.rs +++ b/crates/agent/src/thread_store.rs @@ -41,6 +41,9 @@ use std::{ }; use util::ResultExt as _; +pub static ZED_STATELESS: std::sync::LazyLock = + std::sync::LazyLock::new(|| std::env::var("ZED_STATELESS").map_or(false, |v| !v.is_empty())); + #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] pub enum DataType { #[serde(rename = "json")] @@ -874,7 +877,11 @@ impl ThreadsDatabase { let needs_migration_from_heed = mdb_path.exists(); - let connection = Connection::open_file(&sqlite_path.to_string_lossy()); + let connection = if *ZED_STATELESS { + Connection::open_memory(Some("THREAD_FALLBACK_DB")) + } else { + Connection::open_file(&sqlite_path.to_string_lossy()) + }; connection.exec(indoc! {" CREATE TABLE IF NOT EXISTS threads ( diff --git a/crates/agent_ui/src/agent_configuration.rs b/crates/agent_ui/src/agent_configuration.rs index 1870c3e3d2..cacd409ac6 100644 --- a/crates/agent_ui/src/agent_configuration.rs +++ b/crates/agent_ui/src/agent_configuration.rs @@ -185,6 +185,13 @@ impl AgentConfiguration { None }; + let is_signed_in = self + .workspace + .read_with(cx, |workspace, _| { + workspace.client().status().borrow().is_connected() + }) + .unwrap_or(false); + v_flex() .w_full() .when(is_expanded, |this| this.mb_2()) @@ -233,8 +240,8 @@ impl AgentConfiguration { .size(LabelSize::Large), ) .map(|this| { - if is_zed_provider { - this.gap_2().child( + if is_zed_provider && is_signed_in { + this.child( self.render_zed_plan_info(current_plan, cx), ) } else { diff --git a/crates/agent_ui/src/agent_panel.rs b/crates/agent_ui/src/agent_panel.rs index 6ae2f12b5e..a0250816a0 100644 --- a/crates/agent_ui/src/agent_panel.rs +++ b/crates/agent_ui/src/agent_panel.rs @@ -564,6 +564,17 @@ impl AgentPanel { let inline_assist_context_store = cx.new(|_cx| ContextStore::new(project.downgrade(), Some(thread_store.downgrade()))); + let thread_id = thread.read(cx).id().clone(); + + let history_store = cx.new(|cx| { + HistoryStore::new( + thread_store.clone(), + context_store.clone(), + [HistoryEntryId::Thread(thread_id)], + cx, + ) + }); + let message_editor = cx.new(|cx| { MessageEditor::new( fs.clone(), @@ -573,22 +584,13 @@ impl AgentPanel { prompt_store.clone(), thread_store.downgrade(), context_store.downgrade(), + Some(history_store.downgrade()), thread.clone(), window, cx, ) }); - let thread_id = thread.read(cx).id().clone(); - let history_store = cx.new(|cx| { - HistoryStore::new( - thread_store.clone(), - context_store.clone(), - [HistoryEntryId::Thread(thread_id)], - cx, - ) - }); - cx.observe(&history_store, |_, _, cx| cx.notify()).detach(); let active_thread = cx.new(|cx| { @@ -851,6 +853,7 @@ impl AgentPanel { self.prompt_store.clone(), self.thread_store.downgrade(), self.context_store.downgrade(), + Some(self.history_store.downgrade()), thread.clone(), window, cx, @@ -1124,6 +1127,7 @@ impl AgentPanel { self.prompt_store.clone(), self.thread_store.downgrade(), self.context_store.downgrade(), + Some(self.history_store.downgrade()), thread.clone(), window, cx, @@ -2283,20 +2287,21 @@ impl AgentPanel { } match &self.active_view { - ActiveView::Thread { thread, .. } => thread - .read(cx) - .thread() - .read(cx) - .configured_model() - .map_or(true, |model| { - model.provider.id() == language_model::ZED_CLOUD_PROVIDER_ID - }), - ActiveView::TextThread { .. } => LanguageModelRegistry::global(cx) - .read(cx) - .default_model() - .map_or(true, |model| { - model.provider.id() == language_model::ZED_CLOUD_PROVIDER_ID - }), + ActiveView::Thread { .. } | ActiveView::TextThread { .. } => { + let history_is_empty = self + .history_store + .update(cx, |store, cx| store.recent_entries(1, cx).is_empty()); + + let has_configured_non_zed_providers = LanguageModelRegistry::read_global(cx) + .providers() + .iter() + .any(|provider| { + provider.is_authenticated(cx) + && provider.id() != language_model::ZED_CLOUD_PROVIDER_ID + }); + + history_is_empty || !has_configured_non_zed_providers + } ActiveView::ExternalAgentThread { .. } | ActiveView::History | ActiveView::Configuration => false, @@ -2317,9 +2322,8 @@ impl AgentPanel { Some( div() - .size_full() .when(thread_view, |this| { - this.bg(cx.theme().colors().panel_background) + this.size_full().bg(cx.theme().colors().panel_background) }) .when(text_thread_view, |this| { this.bg(cx.theme().colors().editor_background) diff --git a/crates/agent_ui/src/message_editor.rs b/crates/agent_ui/src/message_editor.rs index 62be5629f1..c160f1de04 100644 --- a/crates/agent_ui/src/message_editor.rs +++ b/crates/agent_ui/src/message_editor.rs @@ -9,6 +9,7 @@ use crate::ui::{ MaxModeTooltip, preview::{AgentPreview, UsageCallout}, }; +use agent::history_store::HistoryStore; use agent::{ context::{AgentContextKey, ContextLoadResult, load_context}, context_store::ContextStoreEvent, @@ -29,8 +30,9 @@ use fs::Fs; use futures::future::Shared; use futures::{FutureExt as _, future}; use gpui::{ - Animation, AnimationExt, App, Entity, EventEmitter, Focusable, KeyContext, Subscription, Task, - TextStyle, WeakEntity, linear_color_stop, linear_gradient, point, pulsating_between, + Animation, AnimationExt, App, Entity, EventEmitter, Focusable, IntoElement, KeyContext, + Subscription, Task, TextStyle, WeakEntity, linear_color_stop, linear_gradient, point, + pulsating_between, }; use language::{Buffer, Language, Point}; use language_model::{ @@ -80,6 +82,7 @@ pub struct MessageEditor { user_store: Entity, context_store: Entity, prompt_store: Option>, + history_store: Option>, context_strip: Entity, context_picker_menu_handle: PopoverMenuHandle, model_selector: Entity, @@ -161,6 +164,7 @@ impl MessageEditor { prompt_store: Option>, thread_store: WeakEntity, text_thread_store: WeakEntity, + history_store: Option>, thread: Entity, window: &mut Window, cx: &mut Context, @@ -233,6 +237,7 @@ impl MessageEditor { workspace, context_store, prompt_store, + history_store, context_strip, context_picker_menu_handle, load_context_task: None, @@ -1661,32 +1666,36 @@ impl Render for MessageEditor { let line_height = TextSize::Small.rems(cx).to_pixels(window.rem_size()) * 1.5; - let in_pro_trial = matches!( - self.user_store.read(cx).current_plan(), - Some(proto::Plan::ZedProTrial) - ); + let has_configured_providers = LanguageModelRegistry::read_global(cx) + .providers() + .iter() + .filter(|provider| { + provider.is_authenticated(cx) && provider.id() != ZED_CLOUD_PROVIDER_ID + }) + .count() + > 0; - let pro_user = matches!( - self.user_store.read(cx).current_plan(), - Some(proto::Plan::ZedPro) - ); + let is_signed_out = self + .workspace + .read_with(cx, |workspace, _| { + workspace.client().status().borrow().is_signed_out() + }) + .unwrap_or(true); - let configured_providers: Vec<(IconName, SharedString)> = - LanguageModelRegistry::read_global(cx) - .providers() - .iter() - .filter(|provider| { - provider.is_authenticated(cx) && provider.id() != ZED_CLOUD_PROVIDER_ID - }) - .map(|provider| (provider.icon(), provider.name().0.clone())) - .collect(); - let has_existing_providers = configured_providers.len() > 0; + let has_history = self + .history_store + .as_ref() + .and_then(|hs| hs.update(cx, |hs, cx| hs.entries(cx).len() > 0).ok()) + .unwrap_or(false) + || self + .thread + .read_with(cx, |thread, _| thread.messages().len() > 0); v_flex() .size_full() .bg(cx.theme().colors().panel_background) .when( - has_existing_providers && !in_pro_trial && !pro_user, + !has_history && is_signed_out && has_configured_providers, |this| this.child(cx.new(ApiKeysWithProviders::new)), ) .when(changed_buffers.len() > 0, |parent| { @@ -1778,6 +1787,7 @@ impl AgentPreview for MessageEditor { None, thread_store.downgrade(), text_thread_store.downgrade(), + None, thread, window, cx, diff --git a/crates/agent_ui/src/ui.rs b/crates/agent_ui/src/ui.rs index 15f2e28e58..b477a8c385 100644 --- a/crates/agent_ui/src/ui.rs +++ b/crates/agent_ui/src/ui.rs @@ -5,7 +5,6 @@ mod end_trial_upsell; mod new_thread_button; mod onboarding_modal; pub mod preview; -mod upsell; pub use agent_notification::*; pub use burn_mode_tooltip::*; diff --git a/crates/agent_ui/src/ui/end_trial_upsell.rs b/crates/agent_ui/src/ui/end_trial_upsell.rs index 9c2dd98d20..36770c2197 100644 --- a/crates/agent_ui/src/ui/end_trial_upsell.rs +++ b/crates/agent_ui/src/ui/end_trial_upsell.rs @@ -3,7 +3,7 @@ use std::sync::Arc; use ai_onboarding::{AgentPanelOnboardingCard, BulletItem}; use client::zed_urls; use gpui::{AnyElement, App, IntoElement, RenderOnce, Window}; -use ui::{Divider, List, prelude::*}; +use ui::{Divider, List, Tooltip, prelude::*}; #[derive(IntoElement, RegisterComponent)] pub struct EndTrialUpsell { @@ -33,14 +33,19 @@ impl RenderOnce for EndTrialUpsell { ) .child( List::new() - .child(BulletItem::new("500 prompts per month with Claude models")) - .child(BulletItem::new("Unlimited edit predictions")), + .child(BulletItem::new("500 prompts with Claude models")) + .child(BulletItem::new( + "Unlimited edit predictions with Zeta, our open-source model", + )), ) .child( Button::new("cta-button", "Upgrade to Zed Pro") .full_width() .style(ButtonStyle::Tinted(ui::TintColor::Accent)) - .on_click(|_, _, cx| cx.open_url(&zed_urls::upgrade_to_zed_pro_url(cx))), + .on_click(move |_, _window, cx| { + telemetry::event!("Upgrade To Pro Clicked", state = "end-of-trial"); + cx.open_url(&zed_urls::upgrade_to_zed_pro_url(cx)) + }), ); let free_section = v_flex() @@ -55,37 +60,43 @@ impl RenderOnce for EndTrialUpsell { .color(Color::Muted) .buffer_font(cx), ) + .child( + Label::new("(Current Plan)") + .size(LabelSize::Small) + .color(Color::Custom(cx.theme().colors().text_muted.opacity(0.6))) + .buffer_font(cx), + ) .child(Divider::horizontal()), ) .child( List::new() - .child(BulletItem::new( - "50 prompts per month with the Claude models", - )) - .child(BulletItem::new( - "2000 accepted edit predictions using our open-source Zeta model", - )), - ) - .child( - Button::new("dismiss-button", "Stay on Free") - .full_width() - .style(ButtonStyle::Outlined) - .on_click({ - let callback = self.dismiss_upsell.clone(); - move |_, window, cx| callback(window, cx) - }), + .child(BulletItem::new("50 prompts with the Claude models")) + .child(BulletItem::new("2,000 accepted edit predictions")), ); AgentPanelOnboardingCard::new() - .child(Headline::new("Your Zed Pro trial has expired.")) + .child(Headline::new("Your Zed Pro Trial has expired")) .child( Label::new("You've been automatically reset to the Free plan.") - .size(LabelSize::Small) .color(Color::Muted) - .mb_1(), + .mb_2(), ) .child(pro_section) .child(free_section) + .child( + h_flex().absolute().top_4().right_4().child( + IconButton::new("dismiss_onboarding", IconName::Close) + .icon_size(IconSize::Small) + .tooltip(Tooltip::text("Dismiss")) + .on_click({ + let callback = self.dismiss_upsell.clone(); + move |_, window, cx| { + telemetry::event!("Banner Dismissed", source = "AI Onboarding"); + callback(window, cx) + } + }), + ), + ) } } diff --git a/crates/agent_ui/src/ui/upsell.rs b/crates/agent_ui/src/ui/upsell.rs deleted file mode 100644 index f311aade22..0000000000 --- a/crates/agent_ui/src/ui/upsell.rs +++ /dev/null @@ -1,163 +0,0 @@ -use component::{Component, ComponentScope, single_example}; -use gpui::{ - AnyElement, App, ClickEvent, IntoElement, ParentElement, RenderOnce, SharedString, Styled, - Window, -}; -use theme::ActiveTheme; -use ui::{ - Button, ButtonCommon, ButtonStyle, Checkbox, Clickable, Color, Label, LabelCommon, - RegisterComponent, ToggleState, h_flex, v_flex, -}; - -/// A component that displays an upsell message with a call-to-action button -/// -/// # Example -/// ``` -/// let upsell = Upsell::new( -/// "Upgrade to Zed Pro", -/// "Get access to advanced AI features and more", -/// "Upgrade Now", -/// Box::new(|_, _window, cx| { -/// cx.open_url("https://zed.dev/pricing"); -/// }), -/// Box::new(|_, _window, cx| { -/// // Handle dismiss -/// }), -/// Box::new(|checked, window, cx| { -/// // Handle don't show again -/// }), -/// ); -/// ``` -#[derive(IntoElement, RegisterComponent)] -pub struct Upsell { - title: SharedString, - message: SharedString, - cta_text: SharedString, - on_click: Box, - on_dismiss: Box, - on_dont_show_again: Box, -} - -impl Upsell { - /// Create a new upsell component - pub fn new( - title: impl Into, - message: impl Into, - cta_text: impl Into, - on_click: Box, - on_dismiss: Box, - on_dont_show_again: Box, - ) -> Self { - Self { - title: title.into(), - message: message.into(), - cta_text: cta_text.into(), - on_click, - on_dismiss, - on_dont_show_again, - } - } -} - -impl RenderOnce for Upsell { - fn render(self, _window: &mut Window, cx: &mut App) -> impl IntoElement { - v_flex() - .w_full() - .p_4() - .gap_3() - .bg(cx.theme().colors().surface_background) - .rounded_md() - .border_1() - .border_color(cx.theme().colors().border) - .child( - v_flex() - .gap_1() - .child( - Label::new(self.title) - .size(ui::LabelSize::Large) - .weight(gpui::FontWeight::BOLD), - ) - .child(Label::new(self.message).color(Color::Muted)), - ) - .child( - h_flex() - .w_full() - .justify_between() - .items_center() - .child( - h_flex() - .items_center() - .gap_1() - .child( - Checkbox::new("dont-show-again", ToggleState::Unselected).on_click( - move |_, window, cx| { - (self.on_dont_show_again)(true, window, cx); - }, - ), - ) - .child( - Label::new("Don't show again") - .color(Color::Muted) - .size(ui::LabelSize::Small), - ), - ) - .child( - h_flex() - .gap_2() - .child( - Button::new("dismiss-button", "No Thanks") - .style(ButtonStyle::Subtle) - .on_click(self.on_dismiss), - ) - .child( - Button::new("cta-button", self.cta_text) - .style(ButtonStyle::Filled) - .on_click(self.on_click), - ), - ), - ) - } -} - -impl Component for Upsell { - fn scope() -> ComponentScope { - ComponentScope::Agent - } - - fn name() -> &'static str { - "Upsell" - } - - fn description() -> Option<&'static str> { - Some("A promotional component that displays a message with a call-to-action.") - } - - fn preview(window: &mut Window, cx: &mut App) -> Option { - let examples = vec![ - single_example( - "Default", - Upsell::new( - "Upgrade to Zed Pro", - "Get unlimited access to AI features and more with Zed Pro. Unlock advanced AI capabilities and other premium features.", - "Upgrade Now", - Box::new(|_, _, _| {}), - Box::new(|_, _, _| {}), - Box::new(|_, _, _| {}), - ).render(window, cx).into_any_element(), - ), - single_example( - "Short Message", - Upsell::new( - "Try Zed Pro for free", - "Start your 7-day trial today.", - "Start Trial", - Box::new(|_, _, _| {}), - Box::new(|_, _, _| {}), - Box::new(|_, _, _| {}), - ).render(window, cx).into_any_element(), - ), - ]; - - Some(v_flex().gap_4().children(examples).into_any_element()) - } -} diff --git a/crates/ai_onboarding/src/agent_panel_onboarding_content.rs b/crates/ai_onboarding/src/agent_panel_onboarding_content.rs index 771482abf3..e8a62f7ff2 100644 --- a/crates/ai_onboarding/src/agent_panel_onboarding_content.rs +++ b/crates/ai_onboarding/src/agent_panel_onboarding_content.rs @@ -61,6 +61,11 @@ impl Render for AgentPanelOnboarding { Some(proto::Plan::ZedProTrial) ); + let is_pro_user = matches!( + self.user_store.read(cx).current_plan(), + Some(proto::Plan::ZedPro) + ); + AgentPanelOnboardingCard::new() .child( ZedAiOnboarding::new( @@ -75,7 +80,7 @@ impl Render for AgentPanelOnboarding { }), ) .map(|this| { - if enrolled_in_trial || self.configured_providers.len() >= 1 { + if enrolled_in_trial || is_pro_user || self.configured_providers.len() >= 1 { this } else { this.child(ApiKeysWithoutProviders::new()) diff --git a/crates/ai_onboarding/src/ai_onboarding.rs b/crates/ai_onboarding/src/ai_onboarding.rs index f9a91503ae..7fffb60ecc 100644 --- a/crates/ai_onboarding/src/ai_onboarding.rs +++ b/crates/ai_onboarding/src/ai_onboarding.rs @@ -16,6 +16,7 @@ use client::{Client, UserStore, zed_urls}; use gpui::{AnyElement, Entity, IntoElement, ParentElement, SharedString}; use ui::{Divider, List, ListItem, RegisterComponent, TintColor, Tooltip, prelude::*}; +#[derive(IntoElement)] pub struct BulletItem { label: SharedString, } @@ -28,18 +29,27 @@ impl BulletItem { } } -impl IntoElement for BulletItem { - type Element = AnyElement; +impl RenderOnce for BulletItem { + fn render(self, window: &mut Window, _cx: &mut App) -> impl IntoElement { + let line_height = 0.85 * window.line_height(); - fn into_element(self) -> Self::Element { ListItem::new("list-item") .selectable(false) - .start_slot( - Icon::new(IconName::Dash) - .size(IconSize::XSmall) - .color(Color::Hidden), + .child( + h_flex() + .w_full() + .min_w_0() + .gap_1() + .items_start() + .child( + h_flex().h(line_height).justify_center().child( + Icon::new(IconName::Dash) + .size(IconSize::XSmall) + .color(Color::Hidden), + ), + ) + .child(div().w_full().min_w_0().child(Label::new(self.label))), ) - .child(div().w_full().child(Label::new(self.label))) .into_any_element() } } @@ -373,7 +383,9 @@ impl ZedAiOnboarding { .child( List::new() .child(BulletItem::new("500 prompts with Claude models")) - .child(BulletItem::new("Unlimited edit predictions")), + .child(BulletItem::new( + "Unlimited edit predictions with Zeta, our open-source model", + )), ) .child( Button::new("pro", "Continue with Zed Pro") diff --git a/crates/assistant_context/src/context_store.rs b/crates/assistant_context/src/context_store.rs index 3400913eb8..3090a7b234 100644 --- a/crates/assistant_context/src/context_store.rs +++ b/crates/assistant_context/src/context_store.rs @@ -767,6 +767,11 @@ impl ContextStore { fn reload(&mut self, cx: &mut Context) -> Task> { let fs = self.fs.clone(); cx.spawn(async move |this, cx| { + pub static ZED_STATELESS: LazyLock = + LazyLock::new(|| std::env::var("ZED_STATELESS").map_or(false, |v| !v.is_empty())); + if *ZED_STATELESS { + return Ok(()); + } fs.create_dir(contexts_dir()).await?; let mut paths = fs.read_dir(contexts_dir()).await?; diff --git a/crates/client/src/user.rs b/crates/client/src/user.rs index f5213fbcb6..5ed258aa8e 100644 --- a/crates/client/src/user.rs +++ b/crates/client/src/user.rs @@ -765,12 +765,14 @@ impl UserStore { pub fn current_plan(&self) -> Option { #[cfg(debug_assertions)] - if let Ok(plan) = std::env::var("ZED_SIMULATE_ZED_PRO_PLAN").as_ref() { + if let Ok(plan) = std::env::var("ZED_SIMULATE_PLAN").as_ref() { return match plan.as_str() { "free" => Some(proto::Plan::Free), "trial" => Some(proto::Plan::ZedProTrial), "pro" => Some(proto::Plan::ZedPro), - _ => None, + _ => { + panic!("ZED_SIMULATE_PLAN must be one of 'free', 'trial', or 'pro'"); + } }; } diff --git a/crates/language_models/src/provider/cloud.rs b/crates/language_models/src/provider/cloud.rs index fac8810714..09a2ac6e0a 100644 --- a/crates/language_models/src/provider/cloud.rs +++ b/crates/language_models/src/provider/cloud.rs @@ -1159,19 +1159,20 @@ impl RenderOnce for ZedAiConfiguration { let manage_subscription_buttons = if is_pro { Button::new("manage_settings", "Manage Subscription") + .full_width() .style(ButtonStyle::Tinted(TintColor::Accent)) .on_click(|_, _, cx| cx.open_url(&zed_urls::account_url(cx))) .into_any_element() } else if self.plan.is_none() || self.eligible_for_trial { Button::new("start_trial", "Start 14-day Free Pro Trial") - .style(ui::ButtonStyle::Tinted(ui::TintColor::Accent)) .full_width() + .style(ui::ButtonStyle::Tinted(ui::TintColor::Accent)) .on_click(|_, _, cx| cx.open_url(&zed_urls::start_trial_url(cx))) .into_any_element() } else { Button::new("upgrade", "Upgrade to Pro") - .style(ui::ButtonStyle::Tinted(ui::TintColor::Accent)) .full_width() + .style(ui::ButtonStyle::Tinted(ui::TintColor::Accent)) .on_click(|_, _, cx| cx.open_url(&zed_urls::upgrade_to_zed_pro_url(cx))) .into_any_element() }; From 7cdd808db23caa9082b542abbd13b1cace73a501 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Pablo=20Ram=C3=B3n=20Guevara?= <50140021+praguevara@users.noreply.github.com> Date: Thu, 24 Jul 2025 16:29:58 +0200 Subject: [PATCH 031/893] helix: Fix replace in helix mode (#34789) Closes https://github.com/zed-industries/zed/issues/33076 Release Notes: - Fixed replace command on helix mode: now it actually replaces what was selected and keeps the replaced text selected to better match helix --- crates/vim/src/helix.rs | 104 +++++++++++++++++++++++++++++++++++++++- crates/vim/src/vim.rs | 1 + 2 files changed, 103 insertions(+), 2 deletions(-) diff --git a/crates/vim/src/helix.rs b/crates/vim/src/helix.rs index 798af3bff3..ca93c9c1de 100644 --- a/crates/vim/src/helix.rs +++ b/crates/vim/src/helix.rs @@ -1,8 +1,8 @@ -use editor::{DisplayPoint, Editor, movement}; +use editor::{DisplayPoint, Editor, SelectionEffects, ToOffset, ToPoint, movement}; use gpui::{Action, actions}; use gpui::{Context, Window}; use language::{CharClassifier, CharKind}; -use text::SelectionGoal; +use text::{Bias, SelectionGoal}; use crate::{ Vim, @@ -341,6 +341,80 @@ impl Vim { }); }); } + + pub fn helix_replace(&mut self, text: &str, window: &mut Window, cx: &mut Context) { + self.update_editor(window, cx, |_, editor, window, cx| { + editor.transact(window, cx, |editor, window, cx| { + let (map, selections) = editor.selections.all_display(cx); + + // Store selection info for positioning after edit + let selection_info: Vec<_> = selections + .iter() + .map(|selection| { + let range = selection.range(); + let start_offset = range.start.to_offset(&map, Bias::Left); + let end_offset = range.end.to_offset(&map, Bias::Left); + let was_empty = range.is_empty(); + let was_reversed = selection.reversed; + ( + map.buffer_snapshot.anchor_at(start_offset, Bias::Left), + end_offset - start_offset, + was_empty, + was_reversed, + ) + }) + .collect(); + + let mut edits = Vec::new(); + for selection in &selections { + let mut range = selection.range(); + + // For empty selections, extend to replace one character + if range.is_empty() { + range.end = movement::saturating_right(&map, range.start); + } + + let byte_range = range.start.to_offset(&map, Bias::Left) + ..range.end.to_offset(&map, Bias::Left); + + if !byte_range.is_empty() { + let replacement_text = text.repeat(byte_range.len()); + edits.push((byte_range, replacement_text)); + } + } + + editor.edit(edits, cx); + + // Restore selections based on original info + let snapshot = editor.buffer().read(cx).snapshot(cx); + let ranges: Vec<_> = selection_info + .into_iter() + .map(|(start_anchor, original_len, was_empty, was_reversed)| { + let start_point = start_anchor.to_point(&snapshot); + if was_empty { + // For cursor-only, collapse to start + start_point..start_point + } else { + // For selections, span the replaced text + let replacement_len = text.len() * original_len; + let end_offset = start_anchor.to_offset(&snapshot) + replacement_len; + let end_point = snapshot.offset_to_point(end_offset); + if was_reversed { + end_point..start_point + } else { + start_point..end_point + } + } + }) + .collect(); + + editor.change_selections(SelectionEffects::no_scroll(), window, cx, |s| { + s.select_ranges(ranges); + }); + }); + }); + self.switch_mode(Mode::HelixNormal, true, window, cx); + } } #[cfg(test)] @@ -603,4 +677,30 @@ mod test { Mode::Insert, ); } + + #[gpui::test] + async fn test_replace(cx: &mut gpui::TestAppContext) { + let mut cx = VimTestContext::new(cx, true).await; + + // No selection (single character) + cx.set_state("ˇaa", Mode::HelixNormal); + + cx.simulate_keystrokes("r x"); + + cx.assert_state("ˇxa", Mode::HelixNormal); + + // Cursor at the beginning + cx.set_state("«ˇaa»", Mode::HelixNormal); + + cx.simulate_keystrokes("r x"); + + cx.assert_state("«ˇxx»", Mode::HelixNormal); + + // Cursor at the end + cx.set_state("«aaˇ»", Mode::HelixNormal); + + cx.simulate_keystrokes("r x"); + + cx.assert_state("«xxˇ»", Mode::HelixNormal); + } } diff --git a/crates/vim/src/vim.rs b/crates/vim/src/vim.rs index 95a08d7c66..c747c30462 100644 --- a/crates/vim/src/vim.rs +++ b/crates/vim/src/vim.rs @@ -1639,6 +1639,7 @@ impl Vim { Mode::Visual | Mode::VisualLine | Mode::VisualBlock => { self.visual_replace(text, window, cx) } + Mode::HelixNormal => self.helix_replace(&text, window, cx), _ => self.clear_operator(window, cx), }, Some(Operator::Digraph { first_char }) => { From fa788a39a4b8dded19cd27d79c9bd0c63d601039 Mon Sep 17 00:00:00 2001 From: Smit Barmase Date: Thu, 24 Jul 2025 20:07:38 +0530 Subject: [PATCH 032/893] project_panel: Reuse `index_for_entry` in `index_for_selection` (#35034) Just refactor I came across while working on another issue. `index_for_entry` and `index_for_selection` have the exact same logic, here we can simply reuse `index_for_entry` for `index_for_selection`. Release Notes: - N/A --- crates/project_panel/src/project_panel.rs | 27 ++++------------------- 1 file changed, 4 insertions(+), 23 deletions(-) diff --git a/crates/project_panel/src/project_panel.rs b/crates/project_panel/src/project_panel.rs index b0073f294f..76be97e393 100644 --- a/crates/project_panel/src/project_panel.rs +++ b/crates/project_panel/src/project_panel.rs @@ -2723,26 +2723,7 @@ impl ProjectPanel { } fn index_for_selection(&self, selection: SelectedEntry) -> Option<(usize, usize, usize)> { - let mut entry_index = 0; - let mut visible_entries_index = 0; - for (worktree_index, (worktree_id, worktree_entries, _)) in - self.visible_entries.iter().enumerate() - { - if *worktree_id == selection.worktree_id { - for entry in worktree_entries { - if entry.id == selection.entry_id { - return Some((worktree_index, entry_index, visible_entries_index)); - } else { - visible_entries_index += 1; - entry_index += 1; - } - } - break; - } else { - visible_entries_index += worktree_entries.len(); - } - } - None + self.index_for_entry(selection.entry_id, selection.worktree_id) } fn disjoint_entries(&self, cx: &App) -> BTreeSet { @@ -3353,12 +3334,12 @@ impl ProjectPanel { entry_id: ProjectEntryId, worktree_id: WorktreeId, ) -> Option<(usize, usize, usize)> { - let mut worktree_ix = 0; let mut total_ix = 0; - for (current_worktree_id, visible_worktree_entries, _) in &self.visible_entries { + for (worktree_ix, (current_worktree_id, visible_worktree_entries, _)) in + self.visible_entries.iter().enumerate() + { if worktree_id != *current_worktree_id { total_ix += visible_worktree_entries.len(); - worktree_ix += 1; continue; } From 2a9355a3d25ddd887556741a30bbafd5d6ff58f0 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Thu, 24 Jul 2025 11:11:26 -0400 Subject: [PATCH 033/893] Don't auto-retry in certain circumstances (#35037) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Someone encountered this in production, which should not happen: Screenshot 2025-07-24 at 10 38 40 AM This moves certain errors into the category of "never retry" and reduces the number of retries for some others. Also it adds some diagnostic logging for retry policy. It's not a complete fix for the above, because the underlying issues is that the server is sending a HTTP 403 response and although we were already treating 403s as "do not retry" it was deciding to retry with 2 attempts anyway. So further debugging is needed to figure out why it wasn't going down the 403 branch by the time the request got here. Release Notes: - N/A --- crates/agent/src/thread.rs | 19 ++++++++++++------- 1 file changed, 12 insertions(+), 7 deletions(-) diff --git a/crates/agent/src/thread.rs b/crates/agent/src/thread.rs index 1b3b022ab2..1af27ca8a7 100644 --- a/crates/agent/src/thread.rs +++ b/crates/agent/src/thread.rs @@ -2037,6 +2037,12 @@ impl Thread { if let Some(retry_strategy) = Thread::get_retry_strategy(completion_error) { + log::info!( + "Retrying with {:?} for language model completion error {:?}", + retry_strategy, + completion_error + ); + retry_scheduled = thread .handle_retryable_error_with_delay( &completion_error, @@ -2246,15 +2252,14 @@ impl Thread { .. } | AuthenticationError { .. } - | PermissionError { .. } => None, - // These errors might be transient, so retry them - SerializeRequest { .. } - | BuildRequestBody { .. } - | PromptTooLarge { .. } + | PermissionError { .. } + | NoApiKey { .. } | ApiEndpointNotFound { .. } - | NoApiKey { .. } => Some(RetryStrategy::Fixed { + | PromptTooLarge { .. } => None, + // These errors might be transient, so retry them + SerializeRequest { .. } | BuildRequestBody { .. } => Some(RetryStrategy::Fixed { delay: BASE_RETRY_DELAY, - max_attempts: 2, + max_attempts: 1, }), // Retry all other 4xx and 5xx errors once. HttpResponseError { status_code, .. } From 2658b2801e382ed01261b4c9566759d735c8ce17 Mon Sep 17 00:00:00 2001 From: Kirill Bulatov Date: Thu, 24 Jul 2025 18:24:53 +0300 Subject: [PATCH 034/893] Shutdown language servers better (#35038) Follow-up of https://github.com/zed-industries/zed/pull/33417 * adjust prettier mock LSP to handle `shutdown` and `exit` messages * removed another `?.log_err()` backtrace from logs and improved the logging info * always handle the last parts of the shutdown logic even if the shutdown response had failed Release Notes: - N/A --- crates/lsp/src/lsp.rs | 56 +++++++++++++------------- crates/prettier/src/prettier_server.js | 4 ++ 2 files changed, 33 insertions(+), 27 deletions(-) diff --git a/crates/lsp/src/lsp.rs b/crates/lsp/src/lsp.rs index a820aaf748..9978d7ebb1 100644 --- a/crates/lsp/src/lsp.rs +++ b/crates/lsp/src/lsp.rs @@ -877,39 +877,41 @@ impl LanguageServer { let server = self.server.clone(); let name = self.name.clone(); + let server_id = self.server_id; let mut timer = self.executor.timer(SERVER_SHUTDOWN_TIMEOUT).fuse(); - Some( - async move { - log::debug!("language server shutdown started"); + Some(async move { + log::debug!("language server shutdown started"); - select! { - request_result = shutdown_request.fuse() => { - match request_result { - ConnectionResult::Timeout => { - log::warn!("timeout waiting for language server {name} to shutdown"); - }, - ConnectionResult::ConnectionReset => {}, - ConnectionResult::Result(r) => r?, - } + select! { + request_result = shutdown_request.fuse() => { + match request_result { + ConnectionResult::Timeout => { + log::warn!("timeout waiting for language server {name} (id {server_id}) to shutdown"); + }, + ConnectionResult::ConnectionReset => { + log::warn!("language server {name} (id {server_id}) closed the shutdown request connection"); + }, + ConnectionResult::Result(Err(e)) => { + log::error!("Shutdown request failure, server {name} (id {server_id}): {e:#}"); + }, + ConnectionResult::Result(Ok(())) => {} } - - _ = timer => { - log::info!("timeout waiting for language server {name} to shutdown"); - }, } - response_handlers.lock().take(); - Self::notify_internal::(&outbound_tx, &()).ok(); - outbound_tx.close(); - output_done.recv().await; - server.lock().take().map(|mut child| child.kill()); - log::debug!("language server shutdown finished"); - - drop(tasks); - anyhow::Ok(()) + _ = timer => { + log::info!("timeout waiting for language server {name} (id {server_id}) to shutdown"); + }, } - .log_err(), - ) + + response_handlers.lock().take(); + Self::notify_internal::(&outbound_tx, &()).ok(); + outbound_tx.close(); + output_done.recv().await; + server.lock().take().map(|mut child| child.kill()); + drop(tasks); + log::debug!("language server shutdown finished"); + Some(()) + }) } else { None } diff --git a/crates/prettier/src/prettier_server.js b/crates/prettier/src/prettier_server.js index 6799b4aceb..b3d8a660a4 100644 --- a/crates/prettier/src/prettier_server.js +++ b/crates/prettier/src/prettier_server.js @@ -152,6 +152,10 @@ async function handleMessage(message, prettier) { throw new Error(`Message method is undefined: ${JSON.stringify(message)}`); } else if (method == "initialized") { return; + } else if (method === "shutdown") { + sendResponse({ result: {} }); + } else if (method == "exit") { + process.exit(0); } if (id === undefined) { From 45ddf32a1d0f8dda645f564486f6a4128dacd1a6 Mon Sep 17 00:00:00 2001 From: "Joseph T. Lyons" Date: Thu, 24 Jul 2025 13:08:02 -0400 Subject: [PATCH 035/893] Fix variable name in project type reporting (#35045) Release Notes: - N/A --- crates/client/src/telemetry.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/crates/client/src/telemetry.rs b/crates/client/src/telemetry.rs index 4983fda5ef..7d39464e4a 100644 --- a/crates/client/src/telemetry.rs +++ b/crates/client/src/telemetry.rs @@ -358,13 +358,13 @@ impl Telemetry { worktree_id: WorktreeId, updated_entries_set: &UpdatedEntriesSet, ) { - let Some(project_type_names) = self.detect_project_types(worktree_id, updated_entries_set) + let Some(project_types) = self.detect_project_types(worktree_id, updated_entries_set) else { return; }; - for project_type_name in project_type_names { - telemetry::event!("Project Opened", project_type = project_type_name); + for project_type in project_types { + telemetry::event!("Project Opened", project_type = project_type); } } From 2d0f10c48a3308bde3079fdb5301006256f8d50b Mon Sep 17 00:00:00 2001 From: Agus Zubiaga Date: Thu, 24 Jul 2025 14:39:29 -0300 Subject: [PATCH 036/893] Refactor to use new ACP crate (#35043) This will prepare us for running the protocol over MCP Release Notes: - N/A --------- Co-authored-by: Ben Brandt Co-authored-by: Conrad Irwin Co-authored-by: Richard Feldman --- Cargo.lock | 15 +- Cargo.toml | 1 + crates/acp_thread/Cargo.toml | 1 + crates/acp_thread/src/acp_thread.rs | 1002 +++++++---------- crates/acp_thread/src/connection.rs | 36 +- crates/acp_thread/src/old_acp_support.rs | 461 ++++++++ crates/agent_servers/Cargo.toml | 1 + crates/agent_servers/src/agent_servers.rs | 11 +- crates/agent_servers/src/claude.rs | 497 ++++---- crates/agent_servers/src/claude/mcp_server.rs | 179 +-- crates/agent_servers/src/claude/tools.rs | 275 ++--- crates/agent_servers/src/e2e_tests.rs | 95 +- crates/agent_servers/src/gemini.rs | 98 +- .../agent_servers/src/stdio_agent_server.rs | 119 -- crates/agent_ui/Cargo.toml | 4 +- crates/agent_ui/src/acp/thread_view.rs | 652 +++++------ crates/agent_ui/src/agent_diff.rs | 6 +- crates/agent_ui/src/agent_panel.rs | 2 +- crates/context_server/src/client.rs | 87 +- crates/context_server/src/protocol.rs | 20 + crates/context_server/src/types.rs | 16 +- 21 files changed, 1830 insertions(+), 1748 deletions(-) create mode 100644 crates/acp_thread/src/old_acp_support.rs delete mode 100644 crates/agent_servers/src/stdio_agent_server.rs diff --git a/Cargo.lock b/Cargo.lock index 8f791d395a..2c65131db0 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -6,6 +6,7 @@ version = 4 name = "acp_thread" version = "0.1.0" dependencies = [ + "agent-client-protocol", "agentic-coding-protocol", "anyhow", "assistant_tool", @@ -135,11 +136,23 @@ dependencies = [ "zstd", ] +[[package]] +name = "agent-client-protocol" +version = "0.0.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7fb7f39671e02f8a1aeb625652feae40b6fc2597baaa97e028a98863477aecbd" +dependencies = [ + "schemars", + "serde", + "serde_json", +] + [[package]] name = "agent_servers" version = "0.1.0" dependencies = [ "acp_thread", + "agent-client-protocol", "agentic-coding-protocol", "anyhow", "collections", @@ -195,9 +208,9 @@ version = "0.1.0" dependencies = [ "acp_thread", "agent", + "agent-client-protocol", "agent_servers", "agent_settings", - "agentic-coding-protocol", "ai_onboarding", "anyhow", "assistant_context", diff --git a/Cargo.toml b/Cargo.toml index ec793a7429..9062950127 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -413,6 +413,7 @@ zlog_settings = { path = "crates/zlog_settings" } # agentic-coding-protocol = "0.0.10" +agent-client-protocol = "0.0.10" aho-corasick = "1.1" alacritty_terminal = { git = "https://github.com/zed-industries/alacritty.git", branch = "add-hush-login-flag" } any_vec = "0.14" diff --git a/crates/acp_thread/Cargo.toml b/crates/acp_thread/Cargo.toml index b44c25ccc9..011f26f364 100644 --- a/crates/acp_thread/Cargo.toml +++ b/crates/acp_thread/Cargo.toml @@ -16,6 +16,7 @@ doctest = false test-support = ["gpui/test-support", "project/test-support"] [dependencies] +agent-client-protocol.workspace = true agentic-coding-protocol.workspace = true anyhow.workspace = true assistant_tool.workspace = true diff --git a/crates/acp_thread/src/acp_thread.rs b/crates/acp_thread/src/acp_thread.rs index 9af1eeb187..3c6c21205f 100644 --- a/crates/acp_thread/src/acp_thread.rs +++ b/crates/acp_thread/src/acp_thread.rs @@ -1,17 +1,15 @@ mod connection; +mod old_acp_support; pub use connection::*; +pub use old_acp_support::*; -pub use acp::ToolCallId; -use agentic_coding_protocol::{ - self as acp, AgentRequest, ProtocolVersion, ToolCallConfirmationOutcome, ToolCallLocation, - UserMessageChunk, -}; +use agent_client_protocol as acp; use anyhow::{Context as _, Result}; use assistant_tool::ActionLog; use buffer_diff::BufferDiff; use editor::{Bias, MultiBuffer, PathKey}; use futures::{FutureExt, channel::oneshot, future::BoxFuture}; -use gpui::{AppContext, AsyncApp, Context, Entity, EventEmitter, SharedString, Task, WeakEntity}; +use gpui::{AppContext, Context, Entity, EventEmitter, SharedString, Task}; use itertools::Itertools; use language::{ Anchor, Buffer, BufferSnapshot, Capability, LanguageRegistry, OffsetRangeExt as _, Point, @@ -21,46 +19,37 @@ use markdown::Markdown; use project::{AgentLocation, Project}; use std::collections::HashMap; use std::error::Error; -use std::fmt::{Formatter, Write}; +use std::fmt::Formatter; +use std::rc::Rc; use std::{ fmt::Display, mem, path::{Path, PathBuf}, sync::Arc, }; -use ui::{App, IconName}; +use ui::App; use util::ResultExt; -#[derive(Clone, Debug, Eq, PartialEq)] +#[derive(Debug)] pub struct UserMessage { - pub content: Entity, + pub content: ContentBlock, } impl UserMessage { pub fn from_acp( - message: &acp::SendUserMessageParams, + message: impl IntoIterator, language_registry: Arc, cx: &mut App, ) -> Self { - let mut md_source = String::new(); - - for chunk in &message.chunks { - match chunk { - UserMessageChunk::Text { text } => md_source.push_str(&text), - UserMessageChunk::Path { path } => { - write!(&mut md_source, "{}", MentionPath(&path)).unwrap() - } - } - } - - Self { - content: cx - .new(|cx| Markdown::new(md_source.into(), Some(language_registry), None, cx)), + let mut content = ContentBlock::Empty; + for chunk in message { + content.append(chunk, &language_registry, cx) } + Self { content: content } } fn to_markdown(&self, cx: &App) -> String { - format!("## User\n\n{}\n\n", self.content.read(cx).source()) + format!("## User\n\n{}\n\n", self.content.to_markdown(cx)) } } @@ -96,7 +85,7 @@ impl Display for MentionPath<'_> { } } -#[derive(Clone, Debug, Eq, PartialEq)] +#[derive(Debug, PartialEq)] pub struct AssistantMessage { pub chunks: Vec, } @@ -113,42 +102,24 @@ impl AssistantMessage { } } -#[derive(Clone, Debug, Eq, PartialEq)] +#[derive(Debug, PartialEq)] pub enum AssistantMessageChunk { - Text { chunk: Entity }, - Thought { chunk: Entity }, + Message { block: ContentBlock }, + Thought { block: ContentBlock }, } impl AssistantMessageChunk { - pub fn from_acp( - chunk: acp::AssistantMessageChunk, - language_registry: Arc, - cx: &mut App, - ) -> Self { - match chunk { - acp::AssistantMessageChunk::Text { text } => Self::Text { - chunk: cx.new(|cx| Markdown::new(text.into(), Some(language_registry), None, cx)), - }, - acp::AssistantMessageChunk::Thought { thought } => Self::Thought { - chunk: cx - .new(|cx| Markdown::new(thought.into(), Some(language_registry), None, cx)), - }, - } - } - - pub fn from_str(chunk: &str, language_registry: Arc, cx: &mut App) -> Self { - Self::Text { - chunk: cx.new(|cx| { - Markdown::new(chunk.to_owned().into(), Some(language_registry), None, cx) - }), + pub fn from_str(chunk: &str, language_registry: &Arc, cx: &mut App) -> Self { + Self::Message { + block: ContentBlock::new(chunk.into(), language_registry, cx), } } fn to_markdown(&self, cx: &App) -> String { match self { - Self::Text { chunk } => chunk.read(cx).source().to_string(), - Self::Thought { chunk } => { - format!("\n{}\n", chunk.read(cx).source()) + Self::Message { block } => block.to_markdown(cx).to_string(), + Self::Thought { block } => { + format!("\n{}\n", block.to_markdown(cx)) } } } @@ -166,19 +137,15 @@ impl AgentThreadEntry { match self { Self::UserMessage(message) => message.to_markdown(cx), Self::AssistantMessage(message) => message.to_markdown(cx), - Self::ToolCall(too_call) => too_call.to_markdown(cx), + Self::ToolCall(tool_call) => tool_call.to_markdown(cx), } } - pub fn diff(&self) -> Option<&Diff> { - if let AgentThreadEntry::ToolCall(ToolCall { - content: Some(ToolCallContent::Diff { diff }), - .. - }) = self - { - Some(&diff) + pub fn diffs(&self) -> impl Iterator { + if let AgentThreadEntry::ToolCall(call) = self { + itertools::Either::Left(call.diffs()) } else { - None + itertools::Either::Right(std::iter::empty()) } } @@ -195,20 +162,54 @@ impl AgentThreadEntry { pub struct ToolCall { pub id: acp::ToolCallId, pub label: Entity, - pub icon: IconName, - pub content: Option, + pub kind: acp::ToolKind, + pub content: Vec, pub status: ToolCallStatus, pub locations: Vec, } impl ToolCall { + fn from_acp( + tool_call: acp::ToolCall, + status: ToolCallStatus, + language_registry: Arc, + cx: &mut App, + ) -> Self { + Self { + id: tool_call.id, + label: cx.new(|cx| { + Markdown::new( + tool_call.label.into(), + Some(language_registry.clone()), + None, + cx, + ) + }), + kind: tool_call.kind, + content: tool_call + .content + .into_iter() + .map(|content| ToolCallContent::from_acp(content, language_registry.clone(), cx)) + .collect(), + locations: tool_call.locations, + status, + } + } + + pub fn diffs(&self) -> impl Iterator { + self.content.iter().filter_map(|content| match content { + ToolCallContent::ContentBlock { .. } => None, + ToolCallContent::Diff { diff } => Some(diff), + }) + } + fn to_markdown(&self, cx: &App) -> String { let mut markdown = format!( "**Tool Call: {}**\nStatus: {}\n\n", self.label.read(cx).source(), self.status ); - if let Some(content) = &self.content { + for content in &self.content { markdown.push_str(content.to_markdown(cx).as_str()); markdown.push_str("\n\n"); } @@ -219,8 +220,8 @@ impl ToolCall { #[derive(Debug)] pub enum ToolCallStatus { WaitingForConfirmation { - confirmation: ToolCallConfirmation, - respond_tx: oneshot::Sender, + options: Vec, + respond_tx: oneshot::Sender, }, Allowed { status: acp::ToolCallStatus, @@ -237,9 +238,9 @@ impl Display for ToolCallStatus { match self { ToolCallStatus::WaitingForConfirmation { .. } => "Waiting for confirmation", ToolCallStatus::Allowed { status } => match status { - acp::ToolCallStatus::Running => "Running", - acp::ToolCallStatus::Finished => "Finished", - acp::ToolCallStatus::Error => "Error", + acp::ToolCallStatus::InProgress => "In Progress", + acp::ToolCallStatus::Completed => "Completed", + acp::ToolCallStatus::Failed => "Failed", }, ToolCallStatus::Rejected => "Rejected", ToolCallStatus::Canceled => "Canceled", @@ -248,86 +249,92 @@ impl Display for ToolCallStatus { } } -#[derive(Debug)] -pub enum ToolCallConfirmation { - Edit { - description: Option>, - }, - Execute { - command: String, - root_command: String, - description: Option>, - }, - Mcp { - server_name: String, - tool_name: String, - tool_display_name: String, - description: Option>, - }, - Fetch { - urls: Vec, - description: Option>, - }, - Other { - description: Entity, - }, +#[derive(Debug, PartialEq, Clone)] +pub enum ContentBlock { + Empty, + Markdown { markdown: Entity }, } -impl ToolCallConfirmation { - pub fn from_acp( - confirmation: acp::ToolCallConfirmation, +impl ContentBlock { + pub fn new( + block: acp::ContentBlock, + language_registry: &Arc, + cx: &mut App, + ) -> Self { + let mut this = Self::Empty; + this.append(block, language_registry, cx); + this + } + + pub fn new_combined( + blocks: impl IntoIterator, language_registry: Arc, cx: &mut App, ) -> Self { - let to_md = |description: String, cx: &mut App| -> Entity { - cx.new(|cx| { - Markdown::new( - description.into(), - Some(language_registry.clone()), - None, - cx, - ) - }) + let mut this = Self::Empty; + for block in blocks { + this.append(block, &language_registry, cx); + } + this + } + + pub fn append( + &mut self, + block: acp::ContentBlock, + language_registry: &Arc, + cx: &mut App, + ) { + let new_content = match block { + acp::ContentBlock::Text(text_content) => text_content.text.clone(), + acp::ContentBlock::ResourceLink(resource_link) => { + if let Some(path) = resource_link.uri.strip_prefix("file://") { + format!("{}", MentionPath(path.as_ref())) + } else { + resource_link.uri.clone() + } + } + acp::ContentBlock::Image(_) + | acp::ContentBlock::Audio(_) + | acp::ContentBlock::Resource(_) => String::new(), }; - match confirmation { - acp::ToolCallConfirmation::Edit { description } => Self::Edit { - description: description.map(|description| to_md(description, cx)), - }, - acp::ToolCallConfirmation::Execute { - command, - root_command, - description, - } => Self::Execute { - command, - root_command, - description: description.map(|description| to_md(description, cx)), - }, - acp::ToolCallConfirmation::Mcp { - server_name, - tool_name, - tool_display_name, - description, - } => Self::Mcp { - server_name, - tool_name, - tool_display_name, - description: description.map(|description| to_md(description, cx)), - }, - acp::ToolCallConfirmation::Fetch { urls, description } => Self::Fetch { - urls: urls.iter().map(|url| url.into()).collect(), - description: description.map(|description| to_md(description, cx)), - }, - acp::ToolCallConfirmation::Other { description } => Self::Other { - description: to_md(description, cx), - }, + match self { + ContentBlock::Empty => { + *self = ContentBlock::Markdown { + markdown: cx.new(|cx| { + Markdown::new( + new_content.into(), + Some(language_registry.clone()), + None, + cx, + ) + }), + }; + } + ContentBlock::Markdown { markdown } => { + markdown.update(cx, |markdown, cx| markdown.append(&new_content, cx)); + } + } + } + + fn to_markdown<'a>(&'a self, cx: &'a App) -> &'a str { + match self { + ContentBlock::Empty => "", + ContentBlock::Markdown { markdown } => markdown.read(cx).source(), + } + } + + pub fn markdown(&self) -> Option<&Entity> { + match self { + ContentBlock::Empty => None, + ContentBlock::Markdown { markdown } => Some(markdown), } } } #[derive(Debug)] pub enum ToolCallContent { - Markdown { markdown: Entity }, + ContentBlock { content: ContentBlock }, Diff { diff: Diff }, } @@ -338,8 +345,8 @@ impl ToolCallContent { cx: &mut App, ) -> Self { match content { - acp::ToolCallContent::Markdown { markdown } => Self::Markdown { - markdown: cx.new(|cx| Markdown::new_text(markdown.into(), cx)), + acp::ToolCallContent::ContentBlock { content } => Self::ContentBlock { + content: ContentBlock::new(content, &language_registry, cx), }, acp::ToolCallContent::Diff { diff } => Self::Diff { diff: Diff::from_acp(diff, language_registry, cx), @@ -347,9 +354,9 @@ impl ToolCallContent { } } - fn to_markdown(&self, cx: &App) -> String { + pub fn to_markdown(&self, cx: &App) -> String { match self { - Self::Markdown { markdown } => markdown.read(cx).source().to_string(), + Self::ContentBlock { content } => content.to_markdown(cx).to_string(), Self::Diff { diff } => diff.to_markdown(cx), } } @@ -520,8 +527,8 @@ pub struct AcpThread { action_log: Entity, shared_buffers: HashMap, BufferSnapshot>, send_task: Option>, - connection: Arc, - child_status: Option>>, + connection: Rc, + session_id: acp::SessionId, } pub enum AcpThreadEvent { @@ -563,10 +570,9 @@ impl Error for LoadError {} impl AcpThread { pub fn new( - connection: impl AgentConnection + 'static, - title: SharedString, - child_status: Option>>, + connection: Rc, project: Entity, + session_id: acp::SessionId, cx: &mut Context, ) -> Self { let action_log = cx.new(|_| ActionLog::new(project.clone())); @@ -576,24 +582,11 @@ impl AcpThread { shared_buffers: Default::default(), entries: Default::default(), plan: Default::default(), - title, + title: connection.name().into(), project, send_task: None, - connection: Arc::new(connection), - child_status, - } - } - - /// Send a request to the agent and wait for a response. - pub fn request( - &self, - params: R, - ) -> impl use + Future> { - let params = params.into_any(); - let result = self.connection.request_any(params); - async move { - let result = result.await?; - Ok(R::response_from_any(result)?) + connection, + session_id, } } @@ -629,15 +622,7 @@ impl AcpThread { for entry in self.entries.iter().rev() { match entry { AgentThreadEntry::UserMessage(_) => return false, - AgentThreadEntry::ToolCall(ToolCall { - status: - ToolCallStatus::Allowed { - status: acp::ToolCallStatus::Running, - .. - }, - content: Some(ToolCallContent::Diff { .. }), - .. - }) => return true, + AgentThreadEntry::ToolCall(call) if call.diffs().next().is_some() => return true, AgentThreadEntry::ToolCall(_) | AgentThreadEntry::AssistantMessage(_) => {} } } @@ -652,42 +637,37 @@ impl AcpThread { pub fn push_assistant_chunk( &mut self, - chunk: acp::AssistantMessageChunk, + chunk: acp::ContentBlock, + is_thought: bool, cx: &mut Context, ) { + let language_registry = self.project.read(cx).languages().clone(); let entries_len = self.entries.len(); if let Some(last_entry) = self.entries.last_mut() && let AgentThreadEntry::AssistantMessage(AssistantMessage { chunks }) = last_entry { cx.emit(AcpThreadEvent::EntryUpdated(entries_len - 1)); - - match (chunks.last_mut(), &chunk) { - ( - Some(AssistantMessageChunk::Text { chunk: old_chunk }), - acp::AssistantMessageChunk::Text { text: new_chunk }, - ) - | ( - Some(AssistantMessageChunk::Thought { chunk: old_chunk }), - acp::AssistantMessageChunk::Thought { thought: new_chunk }, - ) => { - old_chunk.update(cx, |old_chunk, cx| { - old_chunk.append(&new_chunk, cx); - }); + match (chunks.last_mut(), is_thought) { + (Some(AssistantMessageChunk::Message { block }), false) + | (Some(AssistantMessageChunk::Thought { block }), true) => { + block.append(chunk, &language_registry, cx) } _ => { - chunks.push(AssistantMessageChunk::from_acp( - chunk, - self.project.read(cx).languages().clone(), - cx, - )); + let block = ContentBlock::new(chunk, &language_registry, cx); + if is_thought { + chunks.push(AssistantMessageChunk::Thought { block }) + } else { + chunks.push(AssistantMessageChunk::Message { block }) + } } } } else { - let chunk = AssistantMessageChunk::from_acp( - chunk, - self.project.read(cx).languages().clone(), - cx, - ); + let block = ContentBlock::new(chunk, &language_registry, cx); + let chunk = if is_thought { + AssistantMessageChunk::Thought { block } + } else { + AssistantMessageChunk::Message { block } + }; self.push_entry( AgentThreadEntry::AssistantMessage(AssistantMessage { @@ -698,122 +678,122 @@ impl AcpThread { } } - pub fn request_new_tool_call( + pub fn update_tool_call( &mut self, - tool_call: acp::RequestToolCallConfirmationParams, + id: acp::ToolCallId, + status: acp::ToolCallStatus, + content: Option>, cx: &mut Context, - ) -> ToolCallRequest { - let (tx, rx) = oneshot::channel(); + ) -> Result<()> { + let languages = self.project.read(cx).languages().clone(); + let (ix, current_call) = self.tool_call_mut(&id).context("Tool call not found")?; - let status = ToolCallStatus::WaitingForConfirmation { - confirmation: ToolCallConfirmation::from_acp( - tool_call.confirmation, - self.project.read(cx).languages().clone(), - cx, - ), - respond_tx: tx, - }; + if let Some(content) = content { + current_call.content = content + .into_iter() + .map(|chunk| ToolCallContent::from_acp(chunk, languages.clone(), cx)) + .collect(); + } + current_call.status = ToolCallStatus::Allowed { status }; - let id = self.insert_tool_call(tool_call.tool_call, status, cx); - ToolCallRequest { id, outcome: rx } + cx.emit(AcpThreadEvent::EntryUpdated(ix)); + + Ok(()) } - pub fn request_tool_call_confirmation( - &mut self, - tool_call_id: ToolCallId, - confirmation: acp::ToolCallConfirmation, - cx: &mut Context, - ) -> Result { - let project = self.project.read(cx).languages().clone(); - let Some((idx, call)) = self.tool_call_mut(tool_call_id) else { - anyhow::bail!("Tool call not found"); - }; - - let (tx, rx) = oneshot::channel(); - - call.status = ToolCallStatus::WaitingForConfirmation { - confirmation: ToolCallConfirmation::from_acp(confirmation, project, cx), - respond_tx: tx, - }; - - cx.emit(AcpThreadEvent::EntryUpdated(idx)); - - Ok(ToolCallRequest { - id: tool_call_id, - outcome: rx, - }) - } - - pub fn push_tool_call( - &mut self, - request: acp::PushToolCallParams, - cx: &mut Context, - ) -> acp::ToolCallId { + /// Updates a tool call if id matches an existing entry, otherwise inserts a new one. + pub fn upsert_tool_call(&mut self, tool_call: acp::ToolCall, cx: &mut Context) { let status = ToolCallStatus::Allowed { - status: acp::ToolCallStatus::Running, + status: tool_call.status, }; - - self.insert_tool_call(request, status, cx) + self.upsert_tool_call_inner(tool_call, status, cx) } - fn insert_tool_call( + pub fn upsert_tool_call_inner( &mut self, - tool_call: acp::PushToolCallParams, + tool_call: acp::ToolCall, status: ToolCallStatus, cx: &mut Context, - ) -> acp::ToolCallId { + ) { let language_registry = self.project.read(cx).languages().clone(); - let id = acp::ToolCallId(self.entries.len() as u64); - let call = ToolCall { - id, - label: cx.new(|cx| { - Markdown::new( - tool_call.label.into(), - Some(language_registry.clone()), - None, - cx, - ) - }), - icon: acp_icon_to_ui_icon(tool_call.icon), - content: tool_call - .content - .map(|content| ToolCallContent::from_acp(content, language_registry, cx)), - locations: tool_call.locations, - status, - }; + let call = ToolCall::from_acp(tool_call, status, language_registry, cx); let location = call.locations.last().cloned(); + + if let Some((ix, current_call)) = self.tool_call_mut(&call.id) { + *current_call = call; + + cx.emit(AcpThreadEvent::EntryUpdated(ix)); + } else { + self.push_entry(AgentThreadEntry::ToolCall(call), cx); + } + if let Some(location) = location { self.set_project_location(location, cx) } + } - self.push_entry(AgentThreadEntry::ToolCall(call), cx); + fn tool_call_mut(&mut self, id: &acp::ToolCallId) -> Option<(usize, &mut ToolCall)> { + // The tool call we are looking for is typically the last one, or very close to the end. + // At the moment, it doesn't seem like a hashmap would be a good fit for this use case. + self.entries + .iter_mut() + .enumerate() + .rev() + .find_map(|(index, tool_call)| { + if let AgentThreadEntry::ToolCall(tool_call) = tool_call + && &tool_call.id == id + { + Some((index, tool_call)) + } else { + None + } + }) + } - id + pub fn request_tool_call_permission( + &mut self, + tool_call: acp::ToolCall, + options: Vec, + cx: &mut Context, + ) -> oneshot::Receiver { + let (tx, rx) = oneshot::channel(); + + let status = ToolCallStatus::WaitingForConfirmation { + options, + respond_tx: tx, + }; + + self.upsert_tool_call_inner(tool_call, status, cx); + rx } pub fn authorize_tool_call( &mut self, id: acp::ToolCallId, - outcome: acp::ToolCallConfirmationOutcome, + option_id: acp::PermissionOptionId, + option_kind: acp::PermissionOptionKind, cx: &mut Context, ) { - let Some((ix, call)) = self.tool_call_mut(id) else { + let Some((ix, call)) = self.tool_call_mut(&id) else { return; }; - let new_status = if outcome == acp::ToolCallConfirmationOutcome::Reject { - ToolCallStatus::Rejected - } else { - ToolCallStatus::Allowed { - status: acp::ToolCallStatus::Running, + let new_status = match option_kind { + acp::PermissionOptionKind::RejectOnce | acp::PermissionOptionKind::RejectAlways => { + ToolCallStatus::Rejected + } + acp::PermissionOptionKind::AllowOnce | acp::PermissionOptionKind::AllowAlways => { + ToolCallStatus::Allowed { + status: acp::ToolCallStatus::InProgress, + } } }; let curr_status = mem::replace(&mut call.status, new_status); if let ToolCallStatus::WaitingForConfirmation { respond_tx, .. } = curr_status { - respond_tx.send(outcome).log_err(); + respond_tx.send(option_id).log_err(); } else if cfg!(debug_assertions) { panic!("tried to authorize an already authorized tool call"); } @@ -821,70 +801,11 @@ impl AcpThread { cx.emit(AcpThreadEvent::EntryUpdated(ix)); } - pub fn update_tool_call( - &mut self, - id: acp::ToolCallId, - new_status: acp::ToolCallStatus, - new_content: Option, - cx: &mut Context, - ) -> Result<()> { - let language_registry = self.project.read(cx).languages().clone(); - let (ix, call) = self.tool_call_mut(id).context("Entry not found")?; - - if let Some(new_content) = new_content { - call.content = Some(ToolCallContent::from_acp( - new_content, - language_registry, - cx, - )); - } - - match &mut call.status { - ToolCallStatus::Allowed { status } => { - *status = new_status; - } - ToolCallStatus::WaitingForConfirmation { .. } => { - anyhow::bail!("Tool call hasn't been authorized yet") - } - ToolCallStatus::Rejected => { - anyhow::bail!("Tool call was rejected and therefore can't be updated") - } - ToolCallStatus::Canceled => { - call.status = ToolCallStatus::Allowed { status: new_status }; - } - } - - let location = call.locations.last().cloned(); - if let Some(location) = location { - self.set_project_location(location, cx) - } - - cx.emit(AcpThreadEvent::EntryUpdated(ix)); - Ok(()) - } - - fn tool_call_mut(&mut self, id: acp::ToolCallId) -> Option<(usize, &mut ToolCall)> { - let entry = self.entries.get_mut(id.0 as usize); - debug_assert!( - entry.is_some(), - "We shouldn't give out ids to entries that don't exist" - ); - match entry { - Some(AgentThreadEntry::ToolCall(call)) if call.id == id => Some((id.0 as usize, call)), - _ => { - if cfg!(debug_assertions) { - panic!("entry is not a tool call"); - } - None - } - } - } - pub fn plan(&self) -> &Plan { &self.plan } - pub fn update_plan(&mut self, request: acp::UpdatePlanParams, cx: &mut Context) { + pub fn update_plan(&mut self, request: acp::Plan, cx: &mut Context) { self.plan = Plan { entries: request .entries @@ -896,14 +817,14 @@ impl AcpThread { cx.notify(); } - pub fn clear_completed_plan_entries(&mut self, cx: &mut Context) { + fn clear_completed_plan_entries(&mut self, cx: &mut Context) { self.plan .entries .retain(|entry| !matches!(entry.status, acp::PlanEntryStatus::Completed)); cx.notify(); } - pub fn set_project_location(&self, location: ToolCallLocation, cx: &mut Context) { + pub fn set_project_location(&self, location: acp::ToolCallLocation, cx: &mut Context) { self.project.update(cx, |project, cx| { let Some(path) = project.project_path_for_absolute_path(&location.path, cx) else { return; @@ -953,14 +874,8 @@ impl AcpThread { false } - pub fn initialize(&self) -> impl use<> + Future> { - self.request(acp::InitializeParams { - protocol_version: ProtocolVersion::latest(), - }) - } - - pub fn authenticate(&self) -> impl use<> + Future> { - self.request(acp::AuthenticateParams) + pub fn authenticate(&self, cx: &mut App) -> impl use<> + Future> { + self.connection.authenticate(cx) } #[cfg(any(test, feature = "test-support"))] @@ -968,39 +883,50 @@ impl AcpThread { &mut self, message: &str, cx: &mut Context, - ) -> BoxFuture<'static, Result<(), acp::Error>> { + ) -> BoxFuture<'static, Result<()>> { self.send( - acp::SendUserMessageParams { - chunks: vec![acp::UserMessageChunk::Text { - text: message.to_string(), - }], - }, + vec![acp::ContentBlock::Text(acp::TextContent { + text: message.to_string(), + annotations: None, + })], cx, ) } pub fn send( &mut self, - message: acp::SendUserMessageParams, + message: Vec, cx: &mut Context, - ) -> BoxFuture<'static, Result<(), acp::Error>> { - self.push_entry( - AgentThreadEntry::UserMessage(UserMessage::from_acp( - &message, - self.project.read(cx).languages().clone(), - cx, - )), + ) -> BoxFuture<'static, Result<()>> { + let block = ContentBlock::new_combined( + message.clone(), + self.project.read(cx).languages().clone(), cx, ); + self.push_entry( + AgentThreadEntry::UserMessage(UserMessage { content: block }), + cx, + ); + self.clear_completed_plan_entries(cx); let (tx, rx) = oneshot::channel(); - let cancel = self.cancel(cx); + let cancel_task = self.cancel(cx); self.send_task = Some(cx.spawn(async move |this, cx| { async { - cancel.await.log_err(); + cancel_task.await; - let result = this.update(cx, |this, _| this.request(message))?.await; + let result = this + .update(cx, |this, cx| { + this.connection.prompt( + acp::PromptToolArguments { + prompt: message, + session_id: this.session_id.clone(), + }, + cx, + ) + })? + .await; tx.send(result).log_err(); this.update(cx, |this, _cx| this.send_task.take())?; anyhow::Ok(()) @@ -1018,48 +944,38 @@ impl AcpThread { .boxed() } - pub fn cancel(&mut self, cx: &mut Context) -> Task> { - if self.send_task.take().is_some() { - let request = self.request(acp::CancelSendMessageParams); - cx.spawn(async move |this, cx| { - request.await?; - this.update(cx, |this, _cx| { - for entry in this.entries.iter_mut() { - if let AgentThreadEntry::ToolCall(call) = entry { - let cancel = matches!( - call.status, - ToolCallStatus::WaitingForConfirmation { .. } - | ToolCallStatus::Allowed { - status: acp::ToolCallStatus::Running - } - ); + pub fn cancel(&mut self, cx: &mut Context) -> Task<()> { + let Some(send_task) = self.send_task.take() else { + return Task::ready(()); + }; - if cancel { - let curr_status = - mem::replace(&mut call.status, ToolCallStatus::Canceled); - - if let ToolCallStatus::WaitingForConfirmation { - respond_tx, .. - } = curr_status - { - respond_tx - .send(acp::ToolCallConfirmationOutcome::Cancel) - .ok(); - } - } + for entry in self.entries.iter_mut() { + if let AgentThreadEntry::ToolCall(call) = entry { + let cancel = matches!( + call.status, + ToolCallStatus::WaitingForConfirmation { .. } + | ToolCallStatus::Allowed { + status: acp::ToolCallStatus::InProgress } - } - })?; - Ok(()) - }) - } else { - Task::ready(Ok(())) + ); + + if cancel { + call.status = ToolCallStatus::Canceled; + } + } } + + self.connection.cancel(&self.session_id, cx); + + // Wait for the send task to complete + cx.foreground_executor().spawn(send_task) } pub fn read_text_file( &self, - request: acp::ReadTextFileParams, + path: PathBuf, + line: Option, + limit: Option, reuse_shared_snapshot: bool, cx: &mut Context, ) -> Task> { @@ -1068,7 +984,7 @@ impl AcpThread { cx.spawn(async move |this, cx| { let load = project.update(cx, |project, cx| { let path = project - .project_path_for_absolute_path(&request.path, cx) + .project_path_for_absolute_path(&path, cx) .context("invalid path")?; anyhow::Ok(project.open_buffer(path, cx)) }); @@ -1094,7 +1010,7 @@ impl AcpThread { let position = buffer .read(cx) .snapshot() - .anchor_before(Point::new(request.line.unwrap_or_default(), 0)); + .anchor_before(Point::new(line.unwrap_or_default(), 0)); project.set_agent_location( Some(AgentLocation { buffer: buffer.downgrade(), @@ -1110,11 +1026,11 @@ impl AcpThread { this.update(cx, |this, _| { let text = snapshot.text(); this.shared_buffers.insert(buffer.clone(), snapshot); - if request.line.is_none() && request.limit.is_none() { + if line.is_none() && limit.is_none() { return Ok(text); } - let limit = request.limit.unwrap_or(u32::MAX) as usize; - let Some(line) = request.line else { + let limit = limit.unwrap_or(u32::MAX) as usize; + let Some(line) = line else { return Ok(text.lines().take(limit).collect::()); }; @@ -1199,197 +1115,15 @@ impl AcpThread { }) } - pub fn child_status(&mut self) -> Option>> { - self.child_status.take() - } - pub fn to_markdown(&self, cx: &App) -> String { self.entries.iter().map(|e| e.to_markdown(cx)).collect() } } -#[derive(Clone)] -pub struct AcpClientDelegate { - thread: WeakEntity, - cx: AsyncApp, - // sent_buffer_versions: HashMap, HashMap>, -} - -impl AcpClientDelegate { - pub fn new(thread: WeakEntity, cx: AsyncApp) -> Self { - Self { thread, cx } - } - - pub async fn clear_completed_plan_entries(&self) -> Result<()> { - let cx = &mut self.cx.clone(); - cx.update(|cx| { - self.thread - .update(cx, |thread, cx| thread.clear_completed_plan_entries(cx)) - })? - .context("Failed to update thread")?; - - Ok(()) - } - - pub async fn request_existing_tool_call_confirmation( - &self, - tool_call_id: ToolCallId, - confirmation: acp::ToolCallConfirmation, - ) -> Result { - let cx = &mut self.cx.clone(); - let ToolCallRequest { outcome, .. } = cx - .update(|cx| { - self.thread.update(cx, |thread, cx| { - thread.request_tool_call_confirmation(tool_call_id, confirmation, cx) - }) - })? - .context("Failed to update thread")??; - - Ok(outcome.await?) - } - - pub async fn read_text_file_reusing_snapshot( - &self, - request: acp::ReadTextFileParams, - ) -> Result { - let content = self - .cx - .update(|cx| { - self.thread - .update(cx, |thread, cx| thread.read_text_file(request, true, cx)) - })? - .context("Failed to update thread")? - .await?; - Ok(acp::ReadTextFileResponse { content }) - } -} - -impl acp::Client for AcpClientDelegate { - async fn stream_assistant_message_chunk( - &self, - params: acp::StreamAssistantMessageChunkParams, - ) -> Result<(), acp::Error> { - let cx = &mut self.cx.clone(); - - cx.update(|cx| { - self.thread - .update(cx, |thread, cx| { - thread.push_assistant_chunk(params.chunk, cx) - }) - .ok(); - })?; - - Ok(()) - } - - async fn request_tool_call_confirmation( - &self, - request: acp::RequestToolCallConfirmationParams, - ) -> Result { - let cx = &mut self.cx.clone(); - let ToolCallRequest { id, outcome } = cx - .update(|cx| { - self.thread - .update(cx, |thread, cx| thread.request_new_tool_call(request, cx)) - })? - .context("Failed to update thread")?; - - Ok(acp::RequestToolCallConfirmationResponse { - id, - outcome: outcome.await.map_err(acp::Error::into_internal_error)?, - }) - } - - async fn push_tool_call( - &self, - request: acp::PushToolCallParams, - ) -> Result { - let cx = &mut self.cx.clone(); - let id = cx - .update(|cx| { - self.thread - .update(cx, |thread, cx| thread.push_tool_call(request, cx)) - })? - .context("Failed to update thread")?; - - Ok(acp::PushToolCallResponse { id }) - } - - async fn update_tool_call(&self, request: acp::UpdateToolCallParams) -> Result<(), acp::Error> { - let cx = &mut self.cx.clone(); - - cx.update(|cx| { - self.thread.update(cx, |thread, cx| { - thread.update_tool_call(request.tool_call_id, request.status, request.content, cx) - }) - })? - .context("Failed to update thread")??; - - Ok(()) - } - - async fn update_plan(&self, request: acp::UpdatePlanParams) -> Result<(), acp::Error> { - let cx = &mut self.cx.clone(); - - cx.update(|cx| { - self.thread - .update(cx, |thread, cx| thread.update_plan(request, cx)) - })? - .context("Failed to update thread")?; - - Ok(()) - } - - async fn read_text_file( - &self, - request: acp::ReadTextFileParams, - ) -> Result { - let content = self - .cx - .update(|cx| { - self.thread - .update(cx, |thread, cx| thread.read_text_file(request, false, cx)) - })? - .context("Failed to update thread")? - .await?; - Ok(acp::ReadTextFileResponse { content }) - } - - async fn write_text_file(&self, request: acp::WriteTextFileParams) -> Result<(), acp::Error> { - self.cx - .update(|cx| { - self.thread.update(cx, |thread, cx| { - thread.write_text_file(request.path, request.content, cx) - }) - })? - .context("Failed to update thread")? - .await?; - - Ok(()) - } -} - -fn acp_icon_to_ui_icon(icon: acp::Icon) -> IconName { - match icon { - acp::Icon::FileSearch => IconName::ToolSearch, - acp::Icon::Folder => IconName::ToolFolder, - acp::Icon::Globe => IconName::ToolWeb, - acp::Icon::Hammer => IconName::ToolHammer, - acp::Icon::LightBulb => IconName::ToolBulb, - acp::Icon::Pencil => IconName::ToolPencil, - acp::Icon::Regex => IconName::ToolRegex, - acp::Icon::Terminal => IconName::ToolTerminal, - } -} - -pub struct ToolCallRequest { - pub id: acp::ToolCallId, - pub outcome: oneshot::Receiver, -} - #[cfg(test)] mod tests { use super::*; + use agentic_coding_protocol as acp_old; use anyhow::anyhow; use async_pipe::{PipeReader, PipeWriter}; use futures::{channel::mpsc, future::LocalBoxFuture, select}; @@ -1400,6 +1134,7 @@ mod tests { use settings::SettingsStore; use smol::{future::BoxedLocal, stream::StreamExt as _}; use std::{cell::RefCell, rc::Rc, time::Duration}; + use util::path; fn init_test(cx: &mut TestAppContext) { @@ -1424,8 +1159,8 @@ mod tests { fake_server.on_user_message(move |_, server, mut cx| async move { server .update(&mut cx, |server, _| { - server.send_to_zed(acp::StreamAssistantMessageChunkParams { - chunk: acp::AssistantMessageChunk::Thought { + server.send_to_zed(acp_old::StreamAssistantMessageChunkParams { + chunk: acp_old::AssistantMessageChunk::Thought { thought: "Thinking ".into(), }, }) @@ -1434,8 +1169,8 @@ mod tests { .unwrap(); server .update(&mut cx, |server, _| { - server.send_to_zed(acp::StreamAssistantMessageChunkParams { - chunk: acp::AssistantMessageChunk::Thought { + server.send_to_zed(acp_old::StreamAssistantMessageChunkParams { + chunk: acp_old::AssistantMessageChunk::Thought { thought: "hard!".into(), }, }) @@ -1501,7 +1236,7 @@ mod tests { async move { let content = server .update(&mut cx, |server, _| { - server.send_to_zed(acp::ReadTextFileParams { + server.send_to_zed(acp_old::ReadTextFileParams { path: path!("/tmp/foo").into(), line: None, limit: None, @@ -1513,7 +1248,7 @@ mod tests { read_file_tx.take().unwrap().send(()).unwrap(); server .update(&mut cx, |server, _| { - server.send_to_zed(acp::WriteTextFileParams { + server.send_to_zed(acp_old::WriteTextFileParams { path: path!("/tmp/foo").into(), content: "one\ntwo\nthree\nfour\nfive\n".to_string(), }) @@ -1564,9 +1299,9 @@ mod tests { async move { let tool_call_result = server .update(&mut cx, |server, _| { - server.send_to_zed(acp::PushToolCallParams { + server.send_to_zed(acp_old::PushToolCallParams { label: "Fetch".to_string(), - icon: acp::Icon::Globe, + icon: acp_old::Icon::Globe, content: None, locations: vec![], }) @@ -1592,7 +1327,7 @@ mod tests { thread.entries[1], AgentThreadEntry::ToolCall(ToolCall { status: ToolCallStatus::Allowed { - status: acp::ToolCallStatus::Running, + status: acp::ToolCallStatus::InProgress, .. }, .. @@ -1602,10 +1337,7 @@ mod tests { cx.run_until_parked(); - thread - .update(cx, |thread, cx| thread.cancel(cx)) - .await - .unwrap(); + thread.update(cx, |thread, cx| thread.cancel(cx)).await; thread.read_with(cx, |thread, _| { assert!(matches!( @@ -1619,9 +1351,9 @@ mod tests { fake_server .update(cx, |fake_server, _| { - fake_server.send_to_zed(acp::UpdateToolCallParams { + fake_server.send_to_zed(acp_old::UpdateToolCallParams { tool_call_id: tool_call_id.borrow().unwrap(), - status: acp::ToolCallStatus::Finished, + status: acp_old::ToolCallStatus::Finished, content: None, }) }) @@ -1629,14 +1361,14 @@ mod tests { .unwrap(); drop(end_turn_tx); - request.await.unwrap(); + assert!(request.await.unwrap_err().to_string().contains("canceled")); thread.read_with(cx, |thread, _| { assert!(matches!( thread.entries[1], AgentThreadEntry::ToolCall(ToolCall { status: ToolCallStatus::Allowed { - status: acp::ToolCallStatus::Finished, + status: acp::ToolCallStatus::Completed, .. }, .. @@ -1681,8 +1413,10 @@ mod tests { let thread = cx.new(|cx| { let foreground_executor = cx.foreground_executor().clone(); - let (connection, io_fut) = acp::AgentConnection::connect_to_agent( - AcpClientDelegate::new(cx.entity().downgrade(), cx.to_async()), + let thread_rc = Rc::new(RefCell::new(cx.entity().downgrade())); + + let (connection, io_fut) = acp_old::AgentConnection::connect_to_agent( + OldAcpClientDelegate::new(thread_rc.clone(), cx.to_async()), stdin_tx, stdout_rx, move |fut| { @@ -1696,23 +1430,34 @@ mod tests { Ok(()) } }); - AcpThread::new(connection, "Test".into(), Some(io_task), project, cx) + let connection = OldAcpAgentConnection { + name: "test", + connection, + child_status: io_task, + }; + + AcpThread::new( + Rc::new(connection), + project, + acp::SessionId("test".into()), + cx, + ) }); let agent = cx.update(|cx| cx.new(|cx| FakeAcpServer::new(stdin_rx, stdout_tx, cx))); (thread, agent) } pub struct FakeAcpServer { - connection: acp::ClientConnection, + connection: acp_old::ClientConnection, _io_task: Task<()>, on_user_message: Option< Rc< dyn Fn( - acp::SendUserMessageParams, + acp_old::SendUserMessageParams, Entity, AsyncApp, - ) -> LocalBoxFuture<'static, Result<(), acp::Error>>, + ) -> LocalBoxFuture<'static, Result<(), acp_old::Error>>, >, >, } @@ -1721,31 +1466,38 @@ mod tests { struct FakeAgent { server: Entity, cx: AsyncApp, + cancel_tx: Rc>>>, } - impl acp::Agent for FakeAgent { + impl acp_old::Agent for FakeAgent { async fn initialize( &self, - params: acp::InitializeParams, - ) -> Result { - Ok(acp::InitializeResponse { + params: acp_old::InitializeParams, + ) -> Result { + Ok(acp_old::InitializeResponse { protocol_version: params.protocol_version, is_authenticated: true, }) } - async fn authenticate(&self) -> Result<(), acp::Error> { + async fn authenticate(&self) -> Result<(), acp_old::Error> { Ok(()) } - async fn cancel_send_message(&self) -> Result<(), acp::Error> { + async fn cancel_send_message(&self) -> Result<(), acp_old::Error> { + if let Some(cancel_tx) = self.cancel_tx.take() { + cancel_tx.send(()).log_err(); + } Ok(()) } async fn send_user_message( &self, - request: acp::SendUserMessageParams, - ) -> Result<(), acp::Error> { + request: acp_old::SendUserMessageParams, + ) -> Result<(), acp_old::Error> { + let (cancel_tx, cancel_rx) = oneshot::channel(); + self.cancel_tx.replace(Some(cancel_tx)); + let mut cx = self.cx.clone(); let handler = self .server @@ -1753,7 +1505,10 @@ mod tests { .ok() .flatten(); if let Some(handler) = handler { - handler(request, self.server.clone(), self.cx.clone()).await + select! { + _ = cancel_rx.fuse() => Err(anyhow::anyhow!("Message sending canceled").into()), + _ = handler(request, self.server.clone(), self.cx.clone()).fuse() => Ok(()), + } } else { Err(anyhow::anyhow!("No handler for on_user_message").into()) } @@ -1765,10 +1520,11 @@ mod tests { let agent = FakeAgent { server: cx.entity(), cx: cx.to_async(), + cancel_tx: Default::default(), }; let foreground_executor = cx.foreground_executor().clone(); - let (connection, io_fut) = acp::ClientConnection::connect_to_client( + let (connection, io_fut) = acp_old::ClientConnection::connect_to_client( agent.clone(), stdout, stdin, @@ -1787,10 +1543,14 @@ mod tests { fn on_user_message( &mut self, - handler: impl for<'a> Fn(acp::SendUserMessageParams, Entity, AsyncApp) -> F + handler: impl for<'a> Fn( + acp_old::SendUserMessageParams, + Entity, + AsyncApp, + ) -> F + 'static, ) where - F: Future> + 'static, + F: Future> + 'static, { self.on_user_message .replace(Rc::new(move |request, server, cx| { @@ -1798,7 +1558,7 @@ mod tests { })); } - fn send_to_zed( + fn send_to_zed( &self, message: T, ) -> BoxedLocal> { diff --git a/crates/acp_thread/src/connection.rs b/crates/acp_thread/src/connection.rs index 7c0ba4f41c..fde167da5f 100644 --- a/crates/acp_thread/src/connection.rs +++ b/crates/acp_thread/src/connection.rs @@ -1,20 +1,26 @@ -use agentic_coding_protocol as acp; +use std::{path::Path, rc::Rc}; + +use agent_client_protocol as acp; use anyhow::Result; -use futures::future::{FutureExt as _, LocalBoxFuture}; +use gpui::{AsyncApp, Entity, Task}; +use project::Project; +use ui::App; + +use crate::AcpThread; pub trait AgentConnection { - fn request_any( - &self, - params: acp::AnyAgentRequest, - ) -> LocalBoxFuture<'static, Result>; -} + fn name(&self) -> &'static str; -impl AgentConnection for acp::AgentConnection { - fn request_any( - &self, - params: acp::AnyAgentRequest, - ) -> LocalBoxFuture<'static, Result> { - let task = self.request_any(params); - async move { Ok(task.await?) }.boxed_local() - } + fn new_thread( + self: Rc, + project: Entity, + cwd: &Path, + cx: &mut AsyncApp, + ) -> Task>>; + + fn authenticate(&self, cx: &mut App) -> Task>; + + fn prompt(&self, params: acp::PromptToolArguments, cx: &mut App) -> Task>; + + fn cancel(&self, session_id: &acp::SessionId, cx: &mut App); } diff --git a/crates/acp_thread/src/old_acp_support.rs b/crates/acp_thread/src/old_acp_support.rs new file mode 100644 index 0000000000..316a5bcf25 --- /dev/null +++ b/crates/acp_thread/src/old_acp_support.rs @@ -0,0 +1,461 @@ +// Translates old acp agents into the new schema +use agent_client_protocol as acp; +use agentic_coding_protocol::{self as acp_old, AgentRequest as _}; +use anyhow::{Context as _, Result}; +use futures::channel::oneshot; +use gpui::{AppContext as _, AsyncApp, Entity, Task, WeakEntity}; +use project::Project; +use std::{cell::RefCell, error::Error, fmt, path::Path, rc::Rc}; +use ui::App; + +use crate::{AcpThread, AcpThreadEvent, AgentConnection, ToolCallContent, ToolCallStatus}; + +#[derive(Clone)] +pub struct OldAcpClientDelegate { + thread: Rc>>, + cx: AsyncApp, + next_tool_call_id: Rc>, + // sent_buffer_versions: HashMap, HashMap>, +} + +impl OldAcpClientDelegate { + pub fn new(thread: Rc>>, cx: AsyncApp) -> Self { + Self { + thread, + cx, + next_tool_call_id: Rc::new(RefCell::new(0)), + } + } +} + +impl acp_old::Client for OldAcpClientDelegate { + async fn stream_assistant_message_chunk( + &self, + params: acp_old::StreamAssistantMessageChunkParams, + ) -> Result<(), acp_old::Error> { + let cx = &mut self.cx.clone(); + + cx.update(|cx| { + self.thread + .borrow() + .update(cx, |thread, cx| match params.chunk { + acp_old::AssistantMessageChunk::Text { text } => { + thread.push_assistant_chunk(text.into(), false, cx) + } + acp_old::AssistantMessageChunk::Thought { thought } => { + thread.push_assistant_chunk(thought.into(), true, cx) + } + }) + .ok(); + })?; + + Ok(()) + } + + async fn request_tool_call_confirmation( + &self, + request: acp_old::RequestToolCallConfirmationParams, + ) -> Result { + let cx = &mut self.cx.clone(); + + let old_acp_id = *self.next_tool_call_id.borrow() + 1; + self.next_tool_call_id.replace(old_acp_id); + + let tool_call = into_new_tool_call( + acp::ToolCallId(old_acp_id.to_string().into()), + request.tool_call, + ); + + let mut options = match request.confirmation { + acp_old::ToolCallConfirmation::Edit { .. } => vec![( + acp_old::ToolCallConfirmationOutcome::AlwaysAllow, + acp::PermissionOptionKind::AllowAlways, + "Always Allow Edits".to_string(), + )], + acp_old::ToolCallConfirmation::Execute { root_command, .. } => vec![( + acp_old::ToolCallConfirmationOutcome::AlwaysAllow, + acp::PermissionOptionKind::AllowAlways, + format!("Always Allow {}", root_command), + )], + acp_old::ToolCallConfirmation::Mcp { + server_name, + tool_name, + .. + } => vec![ + ( + acp_old::ToolCallConfirmationOutcome::AlwaysAllowMcpServer, + acp::PermissionOptionKind::AllowAlways, + format!("Always Allow {}", server_name), + ), + ( + acp_old::ToolCallConfirmationOutcome::AlwaysAllowTool, + acp::PermissionOptionKind::AllowAlways, + format!("Always Allow {}", tool_name), + ), + ], + acp_old::ToolCallConfirmation::Fetch { .. } => vec![( + acp_old::ToolCallConfirmationOutcome::AlwaysAllow, + acp::PermissionOptionKind::AllowAlways, + "Always Allow".to_string(), + )], + acp_old::ToolCallConfirmation::Other { .. } => vec![( + acp_old::ToolCallConfirmationOutcome::AlwaysAllow, + acp::PermissionOptionKind::AllowAlways, + "Always Allow".to_string(), + )], + }; + + options.extend([ + ( + acp_old::ToolCallConfirmationOutcome::Allow, + acp::PermissionOptionKind::AllowOnce, + "Allow".to_string(), + ), + ( + acp_old::ToolCallConfirmationOutcome::Reject, + acp::PermissionOptionKind::RejectOnce, + "Reject".to_string(), + ), + ]); + + let mut outcomes = Vec::with_capacity(options.len()); + let mut acp_options = Vec::with_capacity(options.len()); + + for (index, (outcome, kind, label)) in options.into_iter().enumerate() { + outcomes.push(outcome); + acp_options.push(acp::PermissionOption { + id: acp::PermissionOptionId(index.to_string().into()), + label, + kind, + }) + } + + let response = cx + .update(|cx| { + self.thread.borrow().update(cx, |thread, cx| { + thread.request_tool_call_permission(tool_call, acp_options, cx) + }) + })? + .context("Failed to update thread")? + .await; + + let outcome = match response { + Ok(option_id) => outcomes[option_id.0.parse::().unwrap_or(0)], + Err(oneshot::Canceled) => acp_old::ToolCallConfirmationOutcome::Cancel, + }; + + Ok(acp_old::RequestToolCallConfirmationResponse { + id: acp_old::ToolCallId(old_acp_id), + outcome: outcome, + }) + } + + async fn push_tool_call( + &self, + request: acp_old::PushToolCallParams, + ) -> Result { + let cx = &mut self.cx.clone(); + + let old_acp_id = *self.next_tool_call_id.borrow() + 1; + self.next_tool_call_id.replace(old_acp_id); + + cx.update(|cx| { + self.thread.borrow().update(cx, |thread, cx| { + thread.upsert_tool_call( + into_new_tool_call(acp::ToolCallId(old_acp_id.to_string().into()), request), + cx, + ) + }) + })? + .context("Failed to update thread")?; + + Ok(acp_old::PushToolCallResponse { + id: acp_old::ToolCallId(old_acp_id), + }) + } + + async fn update_tool_call( + &self, + request: acp_old::UpdateToolCallParams, + ) -> Result<(), acp_old::Error> { + let cx = &mut self.cx.clone(); + + cx.update(|cx| { + self.thread.borrow().update(cx, |thread, cx| { + let languages = thread.project.read(cx).languages().clone(); + + if let Some((ix, tool_call)) = thread + .tool_call_mut(&acp::ToolCallId(request.tool_call_id.0.to_string().into())) + { + tool_call.status = ToolCallStatus::Allowed { + status: into_new_tool_call_status(request.status), + }; + tool_call.content = request + .content + .into_iter() + .map(|content| { + ToolCallContent::from_acp( + into_new_tool_call_content(content), + languages.clone(), + cx, + ) + }) + .collect(); + + cx.emit(AcpThreadEvent::EntryUpdated(ix)); + anyhow::Ok(()) + } else { + anyhow::bail!("Tool call not found") + } + }) + })? + .context("Failed to update thread")??; + + Ok(()) + } + + async fn update_plan(&self, request: acp_old::UpdatePlanParams) -> Result<(), acp_old::Error> { + let cx = &mut self.cx.clone(); + + cx.update(|cx| { + self.thread.borrow().update(cx, |thread, cx| { + thread.update_plan( + acp::Plan { + entries: request + .entries + .into_iter() + .map(into_new_plan_entry) + .collect(), + }, + cx, + ) + }) + })? + .context("Failed to update thread")?; + + Ok(()) + } + + async fn read_text_file( + &self, + acp_old::ReadTextFileParams { path, line, limit }: acp_old::ReadTextFileParams, + ) -> Result { + let content = self + .cx + .update(|cx| { + self.thread.borrow().update(cx, |thread, cx| { + thread.read_text_file(path, line, limit, false, cx) + }) + })? + .context("Failed to update thread")? + .await?; + Ok(acp_old::ReadTextFileResponse { content }) + } + + async fn write_text_file( + &self, + acp_old::WriteTextFileParams { path, content }: acp_old::WriteTextFileParams, + ) -> Result<(), acp_old::Error> { + self.cx + .update(|cx| { + self.thread + .borrow() + .update(cx, |thread, cx| thread.write_text_file(path, content, cx)) + })? + .context("Failed to update thread")? + .await?; + + Ok(()) + } +} + +fn into_new_tool_call(id: acp::ToolCallId, request: acp_old::PushToolCallParams) -> acp::ToolCall { + acp::ToolCall { + id: id, + label: request.label, + kind: acp_kind_from_old_icon(request.icon), + status: acp::ToolCallStatus::InProgress, + content: request + .content + .into_iter() + .map(into_new_tool_call_content) + .collect(), + locations: request + .locations + .into_iter() + .map(into_new_tool_call_location) + .collect(), + } +} + +fn acp_kind_from_old_icon(icon: acp_old::Icon) -> acp::ToolKind { + match icon { + acp_old::Icon::FileSearch => acp::ToolKind::Search, + acp_old::Icon::Folder => acp::ToolKind::Search, + acp_old::Icon::Globe => acp::ToolKind::Search, + acp_old::Icon::Hammer => acp::ToolKind::Other, + acp_old::Icon::LightBulb => acp::ToolKind::Think, + acp_old::Icon::Pencil => acp::ToolKind::Edit, + acp_old::Icon::Regex => acp::ToolKind::Search, + acp_old::Icon::Terminal => acp::ToolKind::Execute, + } +} + +fn into_new_tool_call_status(status: acp_old::ToolCallStatus) -> acp::ToolCallStatus { + match status { + acp_old::ToolCallStatus::Running => acp::ToolCallStatus::InProgress, + acp_old::ToolCallStatus::Finished => acp::ToolCallStatus::Completed, + acp_old::ToolCallStatus::Error => acp::ToolCallStatus::Failed, + } +} + +fn into_new_tool_call_content(content: acp_old::ToolCallContent) -> acp::ToolCallContent { + match content { + acp_old::ToolCallContent::Markdown { markdown } => acp::ToolCallContent::ContentBlock { + content: acp::ContentBlock::Text(acp::TextContent { + annotations: None, + text: markdown, + }), + }, + acp_old::ToolCallContent::Diff { diff } => acp::ToolCallContent::Diff { + diff: into_new_diff(diff), + }, + } +} + +fn into_new_diff(diff: acp_old::Diff) -> acp::Diff { + acp::Diff { + path: diff.path, + old_text: diff.old_text, + new_text: diff.new_text, + } +} + +fn into_new_tool_call_location(location: acp_old::ToolCallLocation) -> acp::ToolCallLocation { + acp::ToolCallLocation { + path: location.path, + line: location.line, + } +} + +fn into_new_plan_entry(entry: acp_old::PlanEntry) -> acp::PlanEntry { + acp::PlanEntry { + content: entry.content, + priority: into_new_plan_priority(entry.priority), + status: into_new_plan_status(entry.status), + } +} + +fn into_new_plan_priority(priority: acp_old::PlanEntryPriority) -> acp::PlanEntryPriority { + match priority { + acp_old::PlanEntryPriority::Low => acp::PlanEntryPriority::Low, + acp_old::PlanEntryPriority::Medium => acp::PlanEntryPriority::Medium, + acp_old::PlanEntryPriority::High => acp::PlanEntryPriority::High, + } +} + +fn into_new_plan_status(status: acp_old::PlanEntryStatus) -> acp::PlanEntryStatus { + match status { + acp_old::PlanEntryStatus::Pending => acp::PlanEntryStatus::Pending, + acp_old::PlanEntryStatus::InProgress => acp::PlanEntryStatus::InProgress, + acp_old::PlanEntryStatus::Completed => acp::PlanEntryStatus::Completed, + } +} + +#[derive(Debug)] +pub struct Unauthenticated; + +impl Error for Unauthenticated {} +impl fmt::Display for Unauthenticated { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "Unauthenticated") + } +} + +pub struct OldAcpAgentConnection { + pub name: &'static str, + pub connection: acp_old::AgentConnection, + pub child_status: Task>, +} + +impl AgentConnection for OldAcpAgentConnection { + fn name(&self) -> &'static str { + self.name + } + + fn new_thread( + self: Rc, + project: Entity, + _cwd: &Path, + cx: &mut AsyncApp, + ) -> Task>> { + let task = self.connection.request_any( + acp_old::InitializeParams { + protocol_version: acp_old::ProtocolVersion::latest(), + } + .into_any(), + ); + cx.spawn(async move |cx| { + let result = task.await?; + let result = acp_old::InitializeParams::response_from_any(result)?; + + if !result.is_authenticated { + anyhow::bail!(Unauthenticated) + } + + cx.update(|cx| { + let thread = cx.new(|cx| { + let session_id = acp::SessionId("acp-old-no-id".into()); + AcpThread::new(self.clone(), project, session_id, cx) + }); + thread + }) + }) + } + + fn authenticate(&self, cx: &mut App) -> Task> { + let task = self + .connection + .request_any(acp_old::AuthenticateParams.into_any()); + cx.foreground_executor().spawn(async move { + task.await?; + Ok(()) + }) + } + + fn prompt(&self, params: acp::PromptToolArguments, cx: &mut App) -> Task> { + let chunks = params + .prompt + .into_iter() + .filter_map(|block| match block { + acp::ContentBlock::Text(text) => { + Some(acp_old::UserMessageChunk::Text { text: text.text }) + } + acp::ContentBlock::ResourceLink(link) => Some(acp_old::UserMessageChunk::Path { + path: link.uri.into(), + }), + _ => None, + }) + .collect(); + + let task = self + .connection + .request_any(acp_old::SendUserMessageParams { chunks }.into_any()); + cx.foreground_executor().spawn(async move { + task.await?; + anyhow::Ok(()) + }) + } + + fn cancel(&self, _session_id: &acp::SessionId, cx: &mut App) { + let task = self + .connection + .request_any(acp_old::CancelSendMessageParams.into_any()); + cx.foreground_executor() + .spawn(async move { + task.await?; + anyhow::Ok(()) + }) + .detach_and_log_err(cx) + } +} diff --git a/crates/agent_servers/Cargo.toml b/crates/agent_servers/Cargo.toml index 4714245b94..4371f7684d 100644 --- a/crates/agent_servers/Cargo.toml +++ b/crates/agent_servers/Cargo.toml @@ -18,6 +18,7 @@ doctest = false [dependencies] acp_thread.workspace = true +agent-client-protocol.workspace = true agentic-coding-protocol.workspace = true anyhow.workspace = true collections.workspace = true diff --git a/crates/agent_servers/src/agent_servers.rs b/crates/agent_servers/src/agent_servers.rs index 6d9c77f296..660f61f907 100644 --- a/crates/agent_servers/src/agent_servers.rs +++ b/crates/agent_servers/src/agent_servers.rs @@ -1,7 +1,6 @@ mod claude; mod gemini; mod settings; -mod stdio_agent_server; #[cfg(test)] mod e2e_tests; @@ -9,9 +8,8 @@ mod e2e_tests; pub use claude::*; pub use gemini::*; pub use settings::*; -pub use stdio_agent_server::*; -use acp_thread::AcpThread; +use acp_thread::AgentConnection; use anyhow::Result; use collections::HashMap; use gpui::{App, AsyncApp, Entity, SharedString, Task}; @@ -20,6 +18,7 @@ use schemars::JsonSchema; use serde::{Deserialize, Serialize}; use std::{ path::{Path, PathBuf}, + rc::Rc, sync::Arc, }; use util::ResultExt as _; @@ -33,14 +32,14 @@ pub trait AgentServer: Send { fn name(&self) -> &'static str; fn empty_state_headline(&self) -> &'static str; fn empty_state_message(&self) -> &'static str; - fn supports_always_allow(&self) -> bool; - fn new_thread( + fn connect( &self, + // these will go away when old_acp is fully removed root_dir: &Path, project: &Entity, cx: &mut App, - ) -> Task>>; + ) -> Task>>; } impl std::fmt::Debug for AgentServerCommand { diff --git a/crates/agent_servers/src/claude.rs b/crates/agent_servers/src/claude.rs index 835efbd655..5f35b4af73 100644 --- a/crates/agent_servers/src/claude.rs +++ b/crates/agent_servers/src/claude.rs @@ -1,5 +1,5 @@ mod mcp_server; -mod tools; +pub mod tools; use collections::HashMap; use project::Project; @@ -12,28 +12,24 @@ use std::pin::pin; use std::rc::Rc; use uuid::Uuid; -use agentic_coding_protocol::{ - self as acp, AnyAgentRequest, AnyAgentResult, Client, ProtocolVersion, - StreamAssistantMessageChunkParams, ToolCallContent, UpdateToolCallParams, -}; +use agent_client_protocol as acp; use anyhow::{Result, anyhow}; use futures::channel::oneshot; -use futures::future::LocalBoxFuture; -use futures::{AsyncBufReadExt, AsyncWriteExt, SinkExt}; +use futures::{AsyncBufReadExt, AsyncWriteExt}; use futures::{ AsyncRead, AsyncWrite, FutureExt, StreamExt, channel::mpsc::{self, UnboundedReceiver, UnboundedSender}, io::BufReader, select_biased, }; -use gpui::{App, AppContext, Entity, Task}; +use gpui::{App, AppContext, AsyncApp, Entity, Task, WeakEntity}; use serde::{Deserialize, Serialize}; use util::ResultExt; -use crate::claude::mcp_server::ClaudeMcpServer; +use crate::claude::mcp_server::{ClaudeZedMcpServer, McpConfig}; use crate::claude::tools::ClaudeTool; use crate::{AgentServer, AgentServerCommand, AllAgentServersSettings}; -use acp_thread::{AcpClientDelegate, AcpThread, AgentConnection}; +use acp_thread::{AcpThread, AgentConnection}; #[derive(Clone)] pub struct ClaudeCode; @@ -55,29 +51,57 @@ impl AgentServer for ClaudeCode { ui::IconName::AiClaude } - fn supports_always_allow(&self) -> bool { - false + fn connect( + &self, + _root_dir: &Path, + _project: &Entity, + _cx: &mut App, + ) -> Task>> { + let connection = ClaudeAgentConnection { + sessions: Default::default(), + }; + + Task::ready(Ok(Rc::new(connection) as _)) + } +} + +#[cfg(unix)] +fn send_interrupt(pid: libc::pid_t) -> anyhow::Result<()> { + let pid = nix::unistd::Pid::from_raw(pid); + + nix::sys::signal::kill(pid, nix::sys::signal::SIGINT) + .map_err(|e| anyhow!("Failed to interrupt process: {}", e)) +} + +#[cfg(windows)] +fn send_interrupt(_pid: i32) -> anyhow::Result<()> { + panic!("Cancel not implemented on Windows") +} + +struct ClaudeAgentConnection { + sessions: Rc>>, +} + +impl AgentConnection for ClaudeAgentConnection { + fn name(&self) -> &'static str { + ClaudeCode.name() } fn new_thread( - &self, - root_dir: &Path, - project: &Entity, - cx: &mut App, + self: Rc, + project: Entity, + cwd: &Path, + cx: &mut AsyncApp, ) -> Task>> { - let project = project.clone(); - let root_dir = root_dir.to_path_buf(); - let title = self.name().into(); + let cwd = cwd.to_owned(); cx.spawn(async move |cx| { - let (mut delegate_tx, delegate_rx) = watch::channel(None); - let tool_id_map = Rc::new(RefCell::new(HashMap::default())); - - let mcp_server = ClaudeMcpServer::new(delegate_rx, tool_id_map.clone(), cx).await?; + let (mut thread_tx, thread_rx) = watch::channel(WeakEntity::new_invalid()); + let permission_mcp_server = ClaudeZedMcpServer::new(thread_rx.clone(), cx).await?; let mut mcp_servers = HashMap::default(); mcp_servers.insert( mcp_server::SERVER_NAME.to_string(), - mcp_server.server_config()?, + permission_mcp_server.server_config()?, ); let mcp_config = McpConfig { mcp_servers }; @@ -104,177 +128,180 @@ impl AgentServer for ClaudeCode { let (outgoing_tx, outgoing_rx) = mpsc::unbounded(); let (cancel_tx, mut cancel_rx) = mpsc::unbounded::>>(); - let session_id = Uuid::new_v4(); + let session_id = acp::SessionId(Uuid::new_v4().to_string().into()); log::trace!("Starting session with id: {}", session_id); - cx.background_spawn(async move { - let mut outgoing_rx = Some(outgoing_rx); - let mut mode = ClaudeSessionMode::Start; + cx.background_spawn({ + let session_id = session_id.clone(); + async move { + let mut outgoing_rx = Some(outgoing_rx); + let mut mode = ClaudeSessionMode::Start; - loop { - let mut child = - spawn_claude(&command, mode, session_id, &mcp_config_path, &root_dir) - .await?; - mode = ClaudeSessionMode::Resume; - - let pid = child.id(); - log::trace!("Spawned (pid: {})", pid); - - let mut io_fut = pin!( - ClaudeAgentConnection::handle_io( - outgoing_rx.take().unwrap(), - incoming_message_tx.clone(), - child.stdin.take().unwrap(), - child.stdout.take().unwrap(), + loop { + let mut child = spawn_claude( + &command, + mode, + session_id.clone(), + &mcp_config_path, + &cwd, ) - .fuse() - ); + .await?; + mode = ClaudeSessionMode::Resume; - select_biased! { - done_tx = cancel_rx.next() => { - if let Some(done_tx) = done_tx { - log::trace!("Interrupted (pid: {})", pid); - let result = send_interrupt(pid as i32); - outgoing_rx.replace(io_fut.await?); - done_tx.send(result).log_err(); - continue; + let pid = child.id(); + log::trace!("Spawned (pid: {})", pid); + + let mut io_fut = pin!( + ClaudeAgentSession::handle_io( + outgoing_rx.take().unwrap(), + incoming_message_tx.clone(), + child.stdin.take().unwrap(), + child.stdout.take().unwrap(), + ) + .fuse() + ); + + select_biased! { + done_tx = cancel_rx.next() => { + if let Some(done_tx) = done_tx { + log::trace!("Interrupted (pid: {})", pid); + let result = send_interrupt(pid as i32); + outgoing_rx.replace(io_fut.await?); + done_tx.send(result).log_err(); + continue; + } + } + result = io_fut => { + result?; } } - result = io_fut => { - result?; - } + + log::trace!("Stopped (pid: {})", pid); + break; } - log::trace!("Stopped (pid: {})", pid); - break; + drop(mcp_config_path); + anyhow::Ok(()) } - - drop(mcp_config_path); - anyhow::Ok(()) }) .detach(); - cx.new(|cx| { - let end_turn_tx = Rc::new(RefCell::new(None)); - let delegate = AcpClientDelegate::new(cx.entity().downgrade(), cx.to_async()); - delegate_tx.send(Some(delegate.clone())).log_err(); - - let handler_task = cx.foreground_executor().spawn({ - let end_turn_tx = end_turn_tx.clone(); - let tool_id_map = tool_id_map.clone(); - let delegate = delegate.clone(); - async move { - while let Some(message) = incoming_message_rx.next().await { - ClaudeAgentConnection::handle_message( - delegate.clone(), - message, - end_turn_tx.clone(), - tool_id_map.clone(), - ) - .await - } + let end_turn_tx = Rc::new(RefCell::new(None)); + let handler_task = cx.spawn({ + let end_turn_tx = end_turn_tx.clone(); + let thread_rx = thread_rx.clone(); + async move |cx| { + while let Some(message) = incoming_message_rx.next().await { + ClaudeAgentSession::handle_message( + thread_rx.clone(), + message, + end_turn_tx.clone(), + cx, + ) + .await } - }); + } + }); - let mut connection = ClaudeAgentConnection { - delegate, - outgoing_tx, - end_turn_tx, - cancel_tx, - session_id, - _handler_task: handler_task, - _mcp_server: None, - }; + let thread = + cx.new(|cx| AcpThread::new(self.clone(), project, session_id.clone(), cx))?; - connection._mcp_server = Some(mcp_server); - acp_thread::AcpThread::new(connection, title, None, project.clone(), cx) - }) + thread_tx.send(thread.downgrade())?; + + let session = ClaudeAgentSession { + outgoing_tx, + end_turn_tx, + cancel_tx, + _handler_task: handler_task, + _mcp_server: Some(permission_mcp_server), + }; + + self.sessions.borrow_mut().insert(session_id, session); + + Ok(thread) }) } -} -#[cfg(unix)] -fn send_interrupt(pid: libc::pid_t) -> anyhow::Result<()> { - let pid = nix::unistd::Pid::from_raw(pid); + fn authenticate(&self, _cx: &mut App) -> Task> { + Task::ready(Err(anyhow!("Authentication not supported"))) + } - nix::sys::signal::kill(pid, nix::sys::signal::SIGINT) - .map_err(|e| anyhow!("Failed to interrupt process: {}", e)) -} + fn prompt(&self, params: acp::PromptToolArguments, cx: &mut App) -> Task> { + let sessions = self.sessions.borrow(); + let Some(session) = sessions.get(¶ms.session_id) else { + return Task::ready(Err(anyhow!( + "Attempted to send message to nonexistent session {}", + params.session_id + ))); + }; -#[cfg(windows)] -fn send_interrupt(_pid: i32) -> anyhow::Result<()> { - panic!("Cancel not implemented on Windows") -} + let (tx, rx) = oneshot::channel(); + session.end_turn_tx.borrow_mut().replace(tx); -impl AgentConnection for ClaudeAgentConnection { - /// Send a request to the agent and wait for a response. - fn request_any( - &self, - params: AnyAgentRequest, - ) -> LocalBoxFuture<'static, Result> { - let delegate = self.delegate.clone(); - let end_turn_tx = self.end_turn_tx.clone(); - let outgoing_tx = self.outgoing_tx.clone(); - let mut cancel_tx = self.cancel_tx.clone(); - let session_id = self.session_id; - async move { - match params { - // todo: consider sending an empty request so we get the init response? - AnyAgentRequest::InitializeParams(_) => Ok(AnyAgentResult::InitializeResponse( - acp::InitializeResponse { - is_authenticated: true, - protocol_version: ProtocolVersion::latest(), - }, - )), - AnyAgentRequest::AuthenticateParams(_) => { - Err(anyhow!("Authentication not supported")) + let mut content = String::new(); + for chunk in params.prompt { + match chunk { + acp::ContentBlock::Text(text_content) => { + content.push_str(&text_content.text); } - AnyAgentRequest::SendUserMessageParams(message) => { - delegate.clear_completed_plan_entries().await?; - - let (tx, rx) = oneshot::channel(); - end_turn_tx.borrow_mut().replace(tx); - let mut content = String::new(); - for chunk in message.chunks { - match chunk { - agentic_coding_protocol::UserMessageChunk::Text { text } => { - content.push_str(&text) - } - agentic_coding_protocol::UserMessageChunk::Path { path } => { - content.push_str(&format!("@{path:?}")) - } - } - } - outgoing_tx.unbounded_send(SdkMessage::User { - message: Message { - role: Role::User, - content: Content::UntaggedText(content), - id: None, - model: None, - stop_reason: None, - stop_sequence: None, - usage: None, - }, - session_id: Some(session_id), - })?; - rx.await??; - Ok(AnyAgentResult::SendUserMessageResponse( - acp::SendUserMessageResponse, - )) + acp::ContentBlock::ResourceLink(resource_link) => { + content.push_str(&format!("@{}", resource_link.uri)); } - AnyAgentRequest::CancelSendMessageParams(_) => { - let (done_tx, done_rx) = oneshot::channel(); - cancel_tx.send(done_tx).await?; - done_rx.await??; - - Ok(AnyAgentResult::CancelSendMessageResponse( - acp::CancelSendMessageResponse, - )) + acp::ContentBlock::Audio(_) + | acp::ContentBlock::Image(_) + | acp::ContentBlock::Resource(_) => { + // TODO } } } - .boxed_local() + + if let Err(err) = session.outgoing_tx.unbounded_send(SdkMessage::User { + message: Message { + role: Role::User, + content: Content::UntaggedText(content), + id: None, + model: None, + stop_reason: None, + stop_sequence: None, + usage: None, + }, + session_id: Some(params.session_id.to_string()), + }) { + return Task::ready(Err(anyhow!(err))); + } + + cx.foreground_executor().spawn(async move { + rx.await??; + Ok(()) + }) + } + + fn cancel(&self, session_id: &acp::SessionId, cx: &mut App) { + let sessions = self.sessions.borrow(); + let Some(session) = sessions.get(&session_id) else { + log::warn!("Attempted to cancel nonexistent session {}", session_id); + return; + }; + + let (done_tx, done_rx) = oneshot::channel(); + if session + .cancel_tx + .unbounded_send(done_tx) + .log_err() + .is_some() + { + let end_turn_tx = session.end_turn_tx.clone(); + cx.foreground_executor() + .spawn(async move { + done_rx.await??; + if let Some(end_turn_tx) = end_turn_tx.take() { + end_turn_tx.send(Ok(())).ok(); + } + anyhow::Ok(()) + }) + .detach_and_log_err(cx); + } } } @@ -287,7 +314,7 @@ enum ClaudeSessionMode { async fn spawn_claude( command: &AgentServerCommand, mode: ClaudeSessionMode, - session_id: Uuid, + session_id: acp::SessionId, mcp_config_path: &Path, root_dir: &Path, ) -> Result { @@ -327,88 +354,103 @@ async fn spawn_claude( Ok(child) } -struct ClaudeAgentConnection { - delegate: AcpClientDelegate, - session_id: Uuid, +struct ClaudeAgentSession { outgoing_tx: UnboundedSender, end_turn_tx: Rc>>>>, cancel_tx: UnboundedSender>>, - _mcp_server: Option, + _mcp_server: Option, _handler_task: Task<()>, } -impl ClaudeAgentConnection { +impl ClaudeAgentSession { async fn handle_message( - delegate: AcpClientDelegate, + mut thread_rx: watch::Receiver>, message: SdkMessage, end_turn_tx: Rc>>>>, - tool_id_map: Rc>>, + cx: &mut AsyncApp, ) { match message { - SdkMessage::Assistant { message, .. } | SdkMessage::User { message, .. } => { + SdkMessage::Assistant { + message, + session_id: _, + } + | SdkMessage::User { + message, + session_id: _, + } => { + let Some(thread) = thread_rx + .recv() + .await + .log_err() + .and_then(|entity| entity.upgrade()) + else { + log::error!("Received an SDK message but thread is gone"); + return; + }; + for chunk in message.content.chunks() { match chunk { ContentChunk::Text { text } | ContentChunk::UntaggedText(text) => { - delegate - .stream_assistant_message_chunk(StreamAssistantMessageChunkParams { - chunk: acp::AssistantMessageChunk::Text { text }, + thread + .update(cx, |thread, cx| { + thread.push_assistant_chunk(text.into(), false, cx) }) - .await .log_err(); } ContentChunk::ToolUse { id, name, input } => { let claude_tool = ClaudeTool::infer(&name, input); - if let ClaudeTool::TodoWrite(Some(params)) = claude_tool { - delegate - .update_plan(acp::UpdatePlanParams { - entries: params.todos.into_iter().map(Into::into).collect(), - }) - .await - .log_err(); - } else if let Some(resp) = delegate - .push_tool_call(claude_tool.as_acp()) - .await - .log_err() - { - tool_id_map.borrow_mut().insert(id, resp.id); - } + thread + .update(cx, |thread, cx| { + if let ClaudeTool::TodoWrite(Some(params)) = claude_tool { + thread.update_plan( + acp::Plan { + entries: params + .todos + .into_iter() + .map(Into::into) + .collect(), + }, + cx, + ) + } else { + thread.upsert_tool_call( + claude_tool.as_acp(acp::ToolCallId(id.into())), + cx, + ); + } + }) + .log_err(); } ContentChunk::ToolResult { content, tool_use_id, } => { - let id = tool_id_map.borrow_mut().remove(&tool_use_id); - if let Some(id) = id { - let content = content.to_string(); - delegate - .update_tool_call(UpdateToolCallParams { - tool_call_id: id, - status: acp::ToolCallStatus::Finished, - // Don't unset existing content - content: (!content.is_empty()).then_some( - ToolCallContent::Markdown { - // For now we only include text content - markdown: content, - }, - ), - }) - .await - .log_err(); - } + let content = content.to_string(); + thread + .update(cx, |thread, cx| { + thread.update_tool_call( + acp::ToolCallId(tool_use_id.into()), + acp::ToolCallStatus::Completed, + (!content.is_empty()).then(|| vec![content.into()]), + cx, + ) + }) + .log_err(); } ContentChunk::Image | ContentChunk::Document | ContentChunk::Thinking | ContentChunk::RedactedThinking | ContentChunk::WebSearchToolResult => { - delegate - .stream_assistant_message_chunk(StreamAssistantMessageChunkParams { - chunk: acp::AssistantMessageChunk::Text { - text: format!("Unsupported content: {:?}", chunk), - }, + thread + .update(cx, |thread, cx| { + thread.push_assistant_chunk( + format!("Unsupported content: {:?}", chunk).into(), + false, + cx, + ) }) - .await .log_err(); } } @@ -592,14 +634,14 @@ enum SdkMessage { Assistant { message: Message, // from Anthropic SDK #[serde(skip_serializing_if = "Option::is_none")] - session_id: Option, + session_id: Option, }, // A user message User { message: Message, // from Anthropic SDK #[serde(skip_serializing_if = "Option::is_none")] - session_id: Option, + session_id: Option, }, // Emitted as the last message in a conversation @@ -661,21 +703,6 @@ enum PermissionMode { Plan, } -#[derive(Serialize)] -#[serde(rename_all = "camelCase")] -struct McpConfig { - mcp_servers: HashMap, -} - -#[derive(Serialize)] -#[serde(rename_all = "camelCase")] -struct McpServerConfig { - command: String, - args: Vec, - #[serde(skip_serializing_if = "Option::is_none")] - env: Option>, -} - #[cfg(test)] pub(crate) mod tests { use super::*; diff --git a/crates/agent_servers/src/claude/mcp_server.rs b/crates/agent_servers/src/claude/mcp_server.rs index 2405603550..0a39a02931 100644 --- a/crates/agent_servers/src/claude/mcp_server.rs +++ b/crates/agent_servers/src/claude/mcp_server.rs @@ -1,29 +1,22 @@ -use std::{cell::RefCell, rc::Rc}; +use std::path::PathBuf; -use acp_thread::AcpClientDelegate; -use agentic_coding_protocol::{self as acp, Client, ReadTextFileParams, WriteTextFileParams}; +use acp_thread::AcpThread; +use agent_client_protocol as acp; use anyhow::{Context, Result}; use collections::HashMap; -use context_server::{ - listener::McpServer, - types::{ - CallToolParams, CallToolResponse, Implementation, InitializeParams, InitializeResponse, - ListToolsResponse, ProtocolVersion, ServerCapabilities, Tool, ToolAnnotations, - ToolResponseContent, ToolsCapabilities, requests, - }, +use context_server::types::{ + CallToolParams, CallToolResponse, Implementation, InitializeParams, InitializeResponse, + ListToolsResponse, ProtocolVersion, ServerCapabilities, Tool, ToolAnnotations, + ToolResponseContent, ToolsCapabilities, requests, }; -use gpui::{App, AsyncApp, Task}; +use gpui::{App, AsyncApp, Entity, Task, WeakEntity}; use schemars::JsonSchema; use serde::{Deserialize, Serialize}; -use util::debug_panic; -use crate::claude::{ - McpServerConfig, - tools::{ClaudeTool, EditToolParams, ReadToolParams}, -}; +use crate::claude::tools::{ClaudeTool, EditToolParams, ReadToolParams}; -pub struct ClaudeMcpServer { - server: McpServer, +pub struct ClaudeZedMcpServer { + server: context_server::listener::McpServer, } pub const SERVER_NAME: &str = "zed"; @@ -52,17 +45,16 @@ enum PermissionToolBehavior { Deny, } -impl ClaudeMcpServer { +impl ClaudeZedMcpServer { pub async fn new( - delegate: watch::Receiver>, - tool_id_map: Rc>>, + thread_rx: watch::Receiver>, cx: &AsyncApp, ) -> Result { - let mut mcp_server = McpServer::new(cx).await?; + let mut mcp_server = context_server::listener::McpServer::new(cx).await?; mcp_server.handle_request::(Self::handle_initialize); mcp_server.handle_request::(Self::handle_list_tools); mcp_server.handle_request::(move |request, cx| { - Self::handle_call_tool(request, delegate.clone(), tool_id_map.clone(), cx) + Self::handle_call_tool(request, thread_rx.clone(), cx) }); Ok(Self { server: mcp_server }) @@ -70,9 +62,7 @@ impl ClaudeMcpServer { pub fn server_config(&self) -> Result { let zed_path = std::env::current_exe() - .context("finding current executable path for use in mcp_server")? - .to_string_lossy() - .to_string(); + .context("finding current executable path for use in mcp_server")?; Ok(McpServerConfig { command: zed_path, @@ -152,22 +142,19 @@ impl ClaudeMcpServer { fn handle_call_tool( request: CallToolParams, - mut delegate_watch: watch::Receiver>, - tool_id_map: Rc>>, + mut thread_rx: watch::Receiver>, cx: &App, ) -> Task> { cx.spawn(async move |cx| { - let Some(delegate) = delegate_watch.recv().await? else { - debug_panic!("Sent None delegate"); - anyhow::bail!("Server not available"); + let Some(thread) = thread_rx.recv().await?.upgrade() else { + anyhow::bail!("Thread closed"); }; if request.name.as_str() == PERMISSION_TOOL { let input = serde_json::from_value(request.arguments.context("Arguments required")?)?; - let result = - Self::handle_permissions_tool_call(input, delegate, tool_id_map, cx).await?; + let result = Self::handle_permissions_tool_call(input, thread, cx).await?; Ok(CallToolResponse { content: vec![ToolResponseContent::Text { text: serde_json::to_string(&result)?, @@ -179,7 +166,7 @@ impl ClaudeMcpServer { let input = serde_json::from_value(request.arguments.context("Arguments required")?)?; - let content = Self::handle_read_tool_call(input, delegate, cx).await?; + let content = Self::handle_read_tool_call(input, thread, cx).await?; Ok(CallToolResponse { content, is_error: None, @@ -189,7 +176,7 @@ impl ClaudeMcpServer { let input = serde_json::from_value(request.arguments.context("Arguments required")?)?; - Self::handle_edit_tool_call(input, delegate, cx).await?; + Self::handle_edit_tool_call(input, thread, cx).await?; Ok(CallToolResponse { content: vec![], is_error: None, @@ -202,49 +189,46 @@ impl ClaudeMcpServer { } fn handle_read_tool_call( - params: ReadToolParams, - delegate: AcpClientDelegate, + ReadToolParams { + abs_path, + offset, + limit, + }: ReadToolParams, + thread: Entity, cx: &AsyncApp, ) -> Task>> { - cx.foreground_executor().spawn(async move { - let response = delegate - .read_text_file(ReadTextFileParams { - path: params.abs_path, - line: params.offset, - limit: params.limit, - }) + cx.spawn(async move |cx| { + let content = thread + .update(cx, |thread, cx| { + thread.read_text_file(abs_path, offset, limit, false, cx) + })? .await?; - Ok(vec![ToolResponseContent::Text { - text: response.content, - }]) + Ok(vec![ToolResponseContent::Text { text: content }]) }) } fn handle_edit_tool_call( params: EditToolParams, - delegate: AcpClientDelegate, + thread: Entity, cx: &AsyncApp, ) -> Task> { - cx.foreground_executor().spawn(async move { - let response = delegate - .read_text_file_reusing_snapshot(ReadTextFileParams { - path: params.abs_path.clone(), - line: None, - limit: None, - }) + cx.spawn(async move |cx| { + let content = thread + .update(cx, |threads, cx| { + threads.read_text_file(params.abs_path.clone(), None, None, true, cx) + })? .await?; - let new_content = response.content.replace(¶ms.old_text, ¶ms.new_text); - if new_content == response.content { + let new_content = content.replace(¶ms.old_text, ¶ms.new_text); + if new_content == content { return Err(anyhow::anyhow!("The old_text was not found in the content")); } - delegate - .write_text_file(WriteTextFileParams { - path: params.abs_path, - content: new_content, - }) + thread + .update(cx, |threads, cx| { + threads.write_text_file(params.abs_path, new_content, cx) + })? .await?; Ok(()) @@ -253,44 +237,65 @@ impl ClaudeMcpServer { fn handle_permissions_tool_call( params: PermissionToolParams, - delegate: AcpClientDelegate, - tool_id_map: Rc>>, + thread: Entity, cx: &AsyncApp, ) -> Task> { - cx.foreground_executor().spawn(async move { + cx.spawn(async move |cx| { let claude_tool = ClaudeTool::infer(¶ms.tool_name, params.input.clone()); - let tool_call_id = match params.tool_use_id { - Some(tool_use_id) => tool_id_map - .borrow() - .get(&tool_use_id) - .cloned() - .context("Tool call ID not found")?, + let tool_call_id = + acp::ToolCallId(params.tool_use_id.context("Tool ID required")?.into()); - None => delegate.push_tool_call(claude_tool.as_acp()).await?.id, - }; + let allow_option_id = acp::PermissionOptionId("allow".into()); + let reject_option_id = acp::PermissionOptionId("reject".into()); - let outcome = delegate - .request_existing_tool_call_confirmation( - tool_call_id, - claude_tool.confirmation(None), - ) + let chosen_option = thread + .update(cx, |thread, cx| { + thread.request_tool_call_permission( + claude_tool.as_acp(tool_call_id), + vec![ + acp::PermissionOption { + id: allow_option_id.clone(), + label: "Allow".into(), + kind: acp::PermissionOptionKind::AllowOnce, + }, + acp::PermissionOption { + id: reject_option_id, + label: "Reject".into(), + kind: acp::PermissionOptionKind::RejectOnce, + }, + ], + cx, + ) + })? .await?; - match outcome { - acp::ToolCallConfirmationOutcome::Allow - | acp::ToolCallConfirmationOutcome::AlwaysAllow - | acp::ToolCallConfirmationOutcome::AlwaysAllowMcpServer - | acp::ToolCallConfirmationOutcome::AlwaysAllowTool => Ok(PermissionToolResponse { + if chosen_option == allow_option_id { + Ok(PermissionToolResponse { behavior: PermissionToolBehavior::Allow, updated_input: params.input, - }), - acp::ToolCallConfirmationOutcome::Reject - | acp::ToolCallConfirmationOutcome::Cancel => Ok(PermissionToolResponse { + }) + } else { + Ok(PermissionToolResponse { behavior: PermissionToolBehavior::Deny, updated_input: params.input, - }), + }) } }) } } + +#[derive(Serialize)] +#[serde(rename_all = "camelCase")] +pub struct McpConfig { + pub mcp_servers: HashMap, +} + +#[derive(Serialize, Clone)] +#[serde(rename_all = "camelCase")] +pub struct McpServerConfig { + pub command: PathBuf, + pub args: Vec, + #[serde(skip_serializing_if = "Option::is_none")] + pub env: Option>, +} diff --git a/crates/agent_servers/src/claude/tools.rs b/crates/agent_servers/src/claude/tools.rs index 75a26ee230..ed25f9af7f 100644 --- a/crates/agent_servers/src/claude/tools.rs +++ b/crates/agent_servers/src/claude/tools.rs @@ -1,6 +1,6 @@ use std::path::PathBuf; -use agentic_coding_protocol::{self as acp, PushToolCallParams, ToolCallLocation}; +use agent_client_protocol as acp; use itertools::Itertools; use schemars::JsonSchema; use serde::{Deserialize, Serialize}; @@ -115,51 +115,36 @@ impl ClaudeTool { Self::Other { name, .. } => name.clone(), } } - - pub fn content(&self) -> Option { + pub fn content(&self) -> Vec { match &self { - Self::Other { input, .. } => Some(acp::ToolCallContent::Markdown { - markdown: format!( + Self::Other { input, .. } => vec![ + format!( "```json\n{}```", serde_json::to_string_pretty(&input).unwrap_or("{}".to_string()) - ), - }), - Self::Task(Some(params)) => Some(acp::ToolCallContent::Markdown { - markdown: params.prompt.clone(), - }), - Self::NotebookRead(Some(params)) => Some(acp::ToolCallContent::Markdown { - markdown: params.notebook_path.display().to_string(), - }), - Self::NotebookEdit(Some(params)) => Some(acp::ToolCallContent::Markdown { - markdown: params.new_source.clone(), - }), - Self::Terminal(Some(params)) => Some(acp::ToolCallContent::Markdown { - markdown: format!( + ) + .into(), + ], + Self::Task(Some(params)) => vec![params.prompt.clone().into()], + Self::NotebookRead(Some(params)) => { + vec![params.notebook_path.display().to_string().into()] + } + Self::NotebookEdit(Some(params)) => vec![params.new_source.clone().into()], + Self::Terminal(Some(params)) => vec![ + format!( "`{}`\n\n{}", params.command, params.description.as_deref().unwrap_or_default() - ), - }), - Self::ReadFile(Some(params)) => Some(acp::ToolCallContent::Markdown { - markdown: params.abs_path.display().to_string(), - }), - Self::Ls(Some(params)) => Some(acp::ToolCallContent::Markdown { - markdown: params.path.display().to_string(), - }), - Self::Glob(Some(params)) => Some(acp::ToolCallContent::Markdown { - markdown: params.to_string(), - }), - Self::Grep(Some(params)) => Some(acp::ToolCallContent::Markdown { - markdown: format!("`{params}`"), - }), - Self::WebFetch(Some(params)) => Some(acp::ToolCallContent::Markdown { - markdown: params.prompt.clone(), - }), - Self::WebSearch(Some(params)) => Some(acp::ToolCallContent::Markdown { - markdown: params.to_string(), - }), - Self::TodoWrite(Some(params)) => Some(acp::ToolCallContent::Markdown { - markdown: params + ) + .into(), + ], + Self::ReadFile(Some(params)) => vec![params.abs_path.display().to_string().into()], + Self::Ls(Some(params)) => vec![params.path.display().to_string().into()], + Self::Glob(Some(params)) => vec![params.to_string().into()], + Self::Grep(Some(params)) => vec![format!("`{params}`").into()], + Self::WebFetch(Some(params)) => vec![params.prompt.clone().into()], + Self::WebSearch(Some(params)) => vec![params.to_string().into()], + Self::TodoWrite(Some(params)) => vec![ + params .todos .iter() .map(|todo| { @@ -174,34 +159,39 @@ impl ClaudeTool { todo.content ) }) - .join("\n"), - }), - Self::ExitPlanMode(Some(params)) => Some(acp::ToolCallContent::Markdown { - markdown: params.plan.clone(), - }), - Self::Edit(Some(params)) => Some(acp::ToolCallContent::Diff { + .join("\n") + .into(), + ], + Self::ExitPlanMode(Some(params)) => vec![params.plan.clone().into()], + Self::Edit(Some(params)) => vec![acp::ToolCallContent::Diff { diff: acp::Diff { path: params.abs_path.clone(), old_text: Some(params.old_text.clone()), new_text: params.new_text.clone(), }, - }), - Self::Write(Some(params)) => Some(acp::ToolCallContent::Diff { + }], + Self::Write(Some(params)) => vec![acp::ToolCallContent::Diff { diff: acp::Diff { path: params.file_path.clone(), old_text: None, new_text: params.content.clone(), }, - }), + }], Self::MultiEdit(Some(params)) => { // todo: show multiple edits in a multibuffer? - params.edits.first().map(|edit| acp::ToolCallContent::Diff { - diff: acp::Diff { - path: params.file_path.clone(), - old_text: Some(edit.old_string.clone()), - new_text: edit.new_string.clone(), - }, - }) + params + .edits + .first() + .map(|edit| { + vec![acp::ToolCallContent::Diff { + diff: acp::Diff { + path: params.file_path.clone(), + old_text: Some(edit.old_string.clone()), + new_text: edit.new_string.clone(), + }, + }] + }) + .unwrap_or_default() } Self::Task(None) | Self::NotebookRead(None) @@ -217,181 +207,80 @@ impl ClaudeTool { | Self::ExitPlanMode(None) | Self::Edit(None) | Self::Write(None) - | Self::MultiEdit(None) => None, + | Self::MultiEdit(None) => vec![], } } - pub fn icon(&self) -> acp::Icon { + pub fn kind(&self) -> acp::ToolKind { match self { - Self::Task(_) => acp::Icon::Hammer, - Self::NotebookRead(_) => acp::Icon::FileSearch, - Self::NotebookEdit(_) => acp::Icon::Pencil, - Self::Edit(_) => acp::Icon::Pencil, - Self::MultiEdit(_) => acp::Icon::Pencil, - Self::Write(_) => acp::Icon::Pencil, - Self::ReadFile(_) => acp::Icon::FileSearch, - Self::Ls(_) => acp::Icon::Folder, - Self::Glob(_) => acp::Icon::FileSearch, - Self::Grep(_) => acp::Icon::Regex, - Self::Terminal(_) => acp::Icon::Terminal, - Self::WebSearch(_) => acp::Icon::Globe, - Self::WebFetch(_) => acp::Icon::Globe, - Self::TodoWrite(_) => acp::Icon::LightBulb, - Self::ExitPlanMode(_) => acp::Icon::Hammer, - Self::Other { .. } => acp::Icon::Hammer, - } - } - - pub fn confirmation(&self, description: Option) -> acp::ToolCallConfirmation { - match &self { - Self::Edit(_) | Self::Write(_) | Self::NotebookEdit(_) | Self::MultiEdit(_) => { - acp::ToolCallConfirmation::Edit { description } - } - Self::WebFetch(params) => acp::ToolCallConfirmation::Fetch { - urls: params - .as_ref() - .map(|p| vec![p.url.clone()]) - .unwrap_or_default(), - description, - }, - Self::Terminal(Some(BashToolParams { - description, - command, - .. - })) => acp::ToolCallConfirmation::Execute { - command: command.clone(), - root_command: command.clone(), - description: description.clone(), - }, - Self::ExitPlanMode(Some(params)) => acp::ToolCallConfirmation::Other { - description: if let Some(description) = description { - format!("{description} {}", params.plan) - } else { - params.plan.clone() - }, - }, - Self::Task(Some(params)) => acp::ToolCallConfirmation::Other { - description: if let Some(description) = description { - format!("{description} {}", params.description) - } else { - params.description.clone() - }, - }, - Self::Ls(Some(LsToolParams { path, .. })) - | Self::ReadFile(Some(ReadToolParams { abs_path: path, .. })) => { - let path = path.display(); - acp::ToolCallConfirmation::Other { - description: if let Some(description) = description { - format!("{description} {path}") - } else { - path.to_string() - }, - } - } - Self::NotebookRead(Some(NotebookReadToolParams { notebook_path, .. })) => { - let path = notebook_path.display(); - acp::ToolCallConfirmation::Other { - description: if let Some(description) = description { - format!("{description} {path}") - } else { - path.to_string() - }, - } - } - Self::Glob(Some(params)) => acp::ToolCallConfirmation::Other { - description: if let Some(description) = description { - format!("{description} {params}") - } else { - params.to_string() - }, - }, - Self::Grep(Some(params)) => acp::ToolCallConfirmation::Other { - description: if let Some(description) = description { - format!("{description} {params}") - } else { - params.to_string() - }, - }, - Self::WebSearch(Some(params)) => acp::ToolCallConfirmation::Other { - description: if let Some(description) = description { - format!("{description} {params}") - } else { - params.to_string() - }, - }, - Self::TodoWrite(Some(params)) => { - let params = params.todos.iter().map(|todo| &todo.content).join(", "); - acp::ToolCallConfirmation::Other { - description: if let Some(description) = description { - format!("{description} {params}") - } else { - params - }, - } - } - Self::Terminal(None) - | Self::Task(None) - | Self::NotebookRead(None) - | Self::ExitPlanMode(None) - | Self::Ls(None) - | Self::Glob(None) - | Self::Grep(None) - | Self::ReadFile(None) - | Self::WebSearch(None) - | Self::TodoWrite(None) - | Self::Other { .. } => acp::ToolCallConfirmation::Other { - description: description.unwrap_or("".to_string()), - }, + Self::Task(_) => acp::ToolKind::Think, + Self::NotebookRead(_) => acp::ToolKind::Read, + Self::NotebookEdit(_) => acp::ToolKind::Edit, + Self::Edit(_) => acp::ToolKind::Edit, + Self::MultiEdit(_) => acp::ToolKind::Edit, + Self::Write(_) => acp::ToolKind::Edit, + Self::ReadFile(_) => acp::ToolKind::Read, + Self::Ls(_) => acp::ToolKind::Search, + Self::Glob(_) => acp::ToolKind::Search, + Self::Grep(_) => acp::ToolKind::Search, + Self::Terminal(_) => acp::ToolKind::Execute, + Self::WebSearch(_) => acp::ToolKind::Search, + Self::WebFetch(_) => acp::ToolKind::Fetch, + Self::TodoWrite(_) => acp::ToolKind::Think, + Self::ExitPlanMode(_) => acp::ToolKind::Think, + Self::Other { .. } => acp::ToolKind::Other, } } pub fn locations(&self) -> Vec { match &self { - Self::Edit(Some(EditToolParams { abs_path, .. })) => vec![ToolCallLocation { + Self::Edit(Some(EditToolParams { abs_path, .. })) => vec![acp::ToolCallLocation { path: abs_path.clone(), line: None, }], Self::MultiEdit(Some(MultiEditToolParams { file_path, .. })) => { - vec![ToolCallLocation { + vec![acp::ToolCallLocation { + path: file_path.clone(), + line: None, + }] + } + Self::Write(Some(WriteToolParams { file_path, .. })) => { + vec![acp::ToolCallLocation { path: file_path.clone(), line: None, }] } - Self::Write(Some(WriteToolParams { file_path, .. })) => vec![ToolCallLocation { - path: file_path.clone(), - line: None, - }], Self::ReadFile(Some(ReadToolParams { abs_path, offset, .. - })) => vec![ToolCallLocation { + })) => vec![acp::ToolCallLocation { path: abs_path.clone(), line: *offset, }], Self::NotebookRead(Some(NotebookReadToolParams { notebook_path, .. })) => { - vec![ToolCallLocation { + vec![acp::ToolCallLocation { path: notebook_path.clone(), line: None, }] } Self::NotebookEdit(Some(NotebookEditToolParams { notebook_path, .. })) => { - vec![ToolCallLocation { + vec![acp::ToolCallLocation { path: notebook_path.clone(), line: None, }] } Self::Glob(Some(GlobToolParams { path: Some(path), .. - })) => vec![ToolCallLocation { + })) => vec![acp::ToolCallLocation { path: path.clone(), line: None, }], - Self::Ls(Some(LsToolParams { path, .. })) => vec![ToolCallLocation { + Self::Ls(Some(LsToolParams { path, .. })) => vec![acp::ToolCallLocation { path: path.clone(), line: None, }], Self::Grep(Some(GrepToolParams { path: Some(path), .. - })) => vec![ToolCallLocation { + })) => vec![acp::ToolCallLocation { path: PathBuf::from(path), line: None, }], @@ -414,11 +303,13 @@ impl ClaudeTool { } } - pub fn as_acp(&self) -> PushToolCallParams { - PushToolCallParams { + pub fn as_acp(&self, id: acp::ToolCallId) -> acp::ToolCall { + acp::ToolCall { + id, + kind: self.kind(), + status: acp::ToolCallStatus::InProgress, label: self.label(), content: self.content(), - icon: self.icon(), locations: self.locations(), } } diff --git a/crates/agent_servers/src/e2e_tests.rs b/crates/agent_servers/src/e2e_tests.rs index 12f74cb13e..9bc6fd60fe 100644 --- a/crates/agent_servers/src/e2e_tests.rs +++ b/crates/agent_servers/src/e2e_tests.rs @@ -1,10 +1,9 @@ use std::{path::Path, sync::Arc, time::Duration}; use crate::{AgentServer, AgentServerSettings, AllAgentServersSettings}; -use acp_thread::{ - AcpThread, AgentThreadEntry, ToolCall, ToolCallConfirmation, ToolCallContent, ToolCallStatus, -}; -use agentic_coding_protocol as acp; +use acp_thread::{AcpThread, AgentThreadEntry, ToolCall, ToolCallStatus}; +use agent_client_protocol as acp; + use futures::{FutureExt, StreamExt, channel::mpsc, select}; use gpui::{Entity, TestAppContext}; use indoc::indoc; @@ -54,19 +53,25 @@ pub async fn test_path_mentions(server: impl AgentServer + 'static, cx: &mut Tes thread .update(cx, |thread, cx| { thread.send( - acp::SendUserMessageParams { - chunks: vec![ - acp::UserMessageChunk::Text { - text: "Read the file ".into(), - }, - acp::UserMessageChunk::Path { - path: Path::new("foo.rs").into(), - }, - acp::UserMessageChunk::Text { - text: " and tell me what the content of the println! is".into(), - }, - ], - }, + vec![ + acp::ContentBlock::Text(acp::TextContent { + text: "Read the file ".into(), + annotations: None, + }), + acp::ContentBlock::ResourceLink(acp::ResourceLink { + uri: "foo.rs".into(), + name: "foo.rs".into(), + annotations: None, + description: None, + mime_type: None, + size: None, + title: None, + }), + acp::ContentBlock::Text(acp::TextContent { + text: " and tell me what the content of the println! is".into(), + annotations: None, + }), + ], cx, ) }) @@ -161,11 +166,8 @@ pub async fn test_tool_call_with_confirmation( let tool_call_id = thread.read_with(cx, |thread, _cx| { let AgentThreadEntry::ToolCall(ToolCall { id, - status: - ToolCallStatus::WaitingForConfirmation { - confirmation: ToolCallConfirmation::Execute { root_command, .. }, - .. - }, + content, + status: ToolCallStatus::WaitingForConfirmation { .. }, .. }) = &thread .entries() @@ -176,13 +178,18 @@ pub async fn test_tool_call_with_confirmation( panic!(); }; - assert!(root_command.contains("touch")); + assert!(content.iter().any(|c| c.to_markdown(_cx).contains("touch"))); - *id + id.clone() }); thread.update(cx, |thread, cx| { - thread.authorize_tool_call(tool_call_id, acp::ToolCallConfirmationOutcome::Allow, cx); + thread.authorize_tool_call( + tool_call_id, + acp::PermissionOptionId("0".into()), + acp::PermissionOptionKind::AllowOnce, + cx, + ); assert!(thread.entries().iter().any(|entry| matches!( entry, @@ -197,7 +204,7 @@ pub async fn test_tool_call_with_confirmation( thread.read_with(cx, |thread, cx| { let AgentThreadEntry::ToolCall(ToolCall { - content: Some(ToolCallContent::Markdown { markdown }), + content, status: ToolCallStatus::Allowed { .. }, .. }) = thread @@ -209,13 +216,10 @@ pub async fn test_tool_call_with_confirmation( panic!(); }; - markdown.read_with(cx, |md, _cx| { - assert!( - md.source().contains("Hello"), - r#"Expected '{}' to contain "Hello""#, - md.source() - ); - }); + assert!( + content.iter().any(|c| c.to_markdown(cx).contains("Hello")), + "Expected content to contain 'Hello'" + ); }); } @@ -249,26 +253,20 @@ pub async fn test_cancel(server: impl AgentServer + 'static, cx: &mut TestAppCon thread.read_with(cx, |thread, _cx| { let AgentThreadEntry::ToolCall(ToolCall { id, - status: - ToolCallStatus::WaitingForConfirmation { - confirmation: ToolCallConfirmation::Execute { root_command, .. }, - .. - }, + content, + status: ToolCallStatus::WaitingForConfirmation { .. }, .. }) = &thread.entries()[first_tool_call_ix] else { panic!("{:?}", thread.entries()[1]); }; - assert!(root_command.contains("touch")); + assert!(content.iter().any(|c| c.to_markdown(_cx).contains("touch"))); - *id + id.clone() }); - thread - .update(cx, |thread, cx| thread.cancel(cx)) - .await - .unwrap(); + let _ = thread.update(cx, |thread, cx| thread.cancel(cx)); full_turn.await.unwrap(); thread.read_with(cx, |thread, _| { let AgentThreadEntry::ToolCall(ToolCall { @@ -369,15 +367,16 @@ pub async fn new_test_thread( current_dir: impl AsRef, cx: &mut TestAppContext, ) -> Entity { - let thread = cx - .update(|cx| server.new_thread(current_dir.as_ref(), &project, cx)) + let connection = cx + .update(|cx| server.connect(current_dir.as_ref(), &project, cx)) .await .unwrap(); - thread - .update(cx, |thread, _| thread.initialize()) + let thread = connection + .new_thread(project.clone(), current_dir.as_ref(), &mut cx.to_async()) .await .unwrap(); + thread } diff --git a/crates/agent_servers/src/gemini.rs b/crates/agent_servers/src/gemini.rs index 8ad147cbff..47b965cdad 100644 --- a/crates/agent_servers/src/gemini.rs +++ b/crates/agent_servers/src/gemini.rs @@ -1,9 +1,17 @@ -use crate::stdio_agent_server::StdioAgentServer; -use crate::{AgentServerCommand, AgentServerVersion}; +use anyhow::anyhow; +use std::cell::RefCell; +use std::path::Path; +use std::rc::Rc; +use util::ResultExt as _; + +use crate::{AgentServer, AgentServerCommand, AgentServerVersion}; +use acp_thread::{AgentConnection, LoadError, OldAcpAgentConnection, OldAcpClientDelegate}; +use agentic_coding_protocol as acp_old; use anyhow::{Context as _, Result}; -use gpui::{AsyncApp, Entity}; +use gpui::{AppContext as _, AsyncApp, Entity, Task, WeakEntity}; use project::Project; use settings::SettingsStore; +use ui::App; use crate::AllAgentServersSettings; @@ -12,7 +20,7 @@ pub struct Gemini; const ACP_ARG: &str = "--experimental-acp"; -impl StdioAgentServer for Gemini { +impl AgentServer for Gemini { fn name(&self) -> &'static str { "Gemini" } @@ -25,14 +33,88 @@ impl StdioAgentServer for Gemini { "Ask questions, edit files, run commands.\nBe specific for the best results." } - fn supports_always_allow(&self) -> bool { - true - } - fn logo(&self) -> ui::IconName { ui::IconName::AiGemini } + fn connect( + &self, + root_dir: &Path, + project: &Entity, + cx: &mut App, + ) -> Task>> { + let root_dir = root_dir.to_path_buf(); + let project = project.clone(); + let this = self.clone(); + let name = self.name(); + + cx.spawn(async move |cx| { + let command = this.command(&project, cx).await?; + + let mut child = util::command::new_smol_command(&command.path) + .args(command.args.iter()) + .current_dir(root_dir) + .stdin(std::process::Stdio::piped()) + .stdout(std::process::Stdio::piped()) + .stderr(std::process::Stdio::inherit()) + .kill_on_drop(true) + .spawn()?; + + let stdin = child.stdin.take().unwrap(); + let stdout = child.stdout.take().unwrap(); + + let foreground_executor = cx.foreground_executor().clone(); + + let thread_rc = Rc::new(RefCell::new(WeakEntity::new_invalid())); + + let (connection, io_fut) = acp_old::AgentConnection::connect_to_agent( + OldAcpClientDelegate::new(thread_rc.clone(), cx.clone()), + stdin, + stdout, + move |fut| foreground_executor.spawn(fut).detach(), + ); + + let io_task = cx.background_spawn(async move { + io_fut.await.log_err(); + }); + + let child_status = cx.background_spawn(async move { + let result = match child.status().await { + Err(e) => Err(anyhow!(e)), + Ok(result) if result.success() => Ok(()), + Ok(result) => { + if let Some(AgentServerVersion::Unsupported { + error_message, + upgrade_message, + upgrade_command, + }) = this.version(&command).await.log_err() + { + Err(anyhow!(LoadError::Unsupported { + error_message, + upgrade_message, + upgrade_command + })) + } else { + Err(anyhow!(LoadError::Exited(result.code().unwrap_or(-127)))) + } + } + }; + drop(io_task); + result + }); + + let connection: Rc = Rc::new(OldAcpAgentConnection { + name, + connection, + child_status, + }); + + Ok(connection) + }) + } +} + +impl Gemini { async fn command( &self, project: &Entity, diff --git a/crates/agent_servers/src/stdio_agent_server.rs b/crates/agent_servers/src/stdio_agent_server.rs deleted file mode 100644 index e60dd39de4..0000000000 --- a/crates/agent_servers/src/stdio_agent_server.rs +++ /dev/null @@ -1,119 +0,0 @@ -use crate::{AgentServer, AgentServerCommand, AgentServerVersion}; -use acp_thread::{AcpClientDelegate, AcpThread, LoadError}; -use agentic_coding_protocol as acp; -use anyhow::{Result, anyhow}; -use gpui::{App, AsyncApp, Entity, Task, prelude::*}; -use project::Project; -use std::path::Path; -use util::ResultExt; - -pub trait StdioAgentServer: Send + Clone { - fn logo(&self) -> ui::IconName; - fn name(&self) -> &'static str; - fn empty_state_headline(&self) -> &'static str; - fn empty_state_message(&self) -> &'static str; - fn supports_always_allow(&self) -> bool; - - fn command( - &self, - project: &Entity, - cx: &mut AsyncApp, - ) -> impl Future>; - - fn version( - &self, - command: &AgentServerCommand, - ) -> impl Future> + Send; -} - -impl AgentServer for T { - fn name(&self) -> &'static str { - self.name() - } - - fn empty_state_headline(&self) -> &'static str { - self.empty_state_headline() - } - - fn empty_state_message(&self) -> &'static str { - self.empty_state_message() - } - - fn logo(&self) -> ui::IconName { - self.logo() - } - - fn supports_always_allow(&self) -> bool { - self.supports_always_allow() - } - - fn new_thread( - &self, - root_dir: &Path, - project: &Entity, - cx: &mut App, - ) -> Task>> { - let root_dir = root_dir.to_path_buf(); - let project = project.clone(); - let this = self.clone(); - let title = self.name().into(); - - cx.spawn(async move |cx| { - let command = this.command(&project, cx).await?; - - let mut child = util::command::new_smol_command(&command.path) - .args(command.args.iter()) - .current_dir(root_dir) - .stdin(std::process::Stdio::piped()) - .stdout(std::process::Stdio::piped()) - .stderr(std::process::Stdio::inherit()) - .kill_on_drop(true) - .spawn()?; - - let stdin = child.stdin.take().unwrap(); - let stdout = child.stdout.take().unwrap(); - - cx.new(|cx| { - let foreground_executor = cx.foreground_executor().clone(); - - let (connection, io_fut) = acp::AgentConnection::connect_to_agent( - AcpClientDelegate::new(cx.entity().downgrade(), cx.to_async()), - stdin, - stdout, - move |fut| foreground_executor.spawn(fut).detach(), - ); - - let io_task = cx.background_spawn(async move { - io_fut.await.log_err(); - }); - - let child_status = cx.background_spawn(async move { - let result = match child.status().await { - Err(e) => Err(anyhow!(e)), - Ok(result) if result.success() => Ok(()), - Ok(result) => { - if let Some(AgentServerVersion::Unsupported { - error_message, - upgrade_message, - upgrade_command, - }) = this.version(&command).await.log_err() - { - Err(anyhow!(LoadError::Unsupported { - error_message, - upgrade_message, - upgrade_command - })) - } else { - Err(anyhow!(LoadError::Exited(result.code().unwrap_or(-127)))) - } - } - }; - drop(io_task); - result - }); - - AcpThread::new(connection, title, Some(child_status), project.clone(), cx) - }) - }) - } -} diff --git a/crates/agent_ui/Cargo.toml b/crates/agent_ui/Cargo.toml index 7d3b84e42e..fbd53e8d09 100644 --- a/crates/agent_ui/Cargo.toml +++ b/crates/agent_ui/Cargo.toml @@ -17,10 +17,10 @@ test-support = ["gpui/test-support", "language/test-support"] [dependencies] acp_thread.workspace = true +agent-client-protocol.workspace = true agent.workspace = true -agentic-coding-protocol.workspace = true -agent_settings.workspace = true agent_servers.workspace = true +agent_settings.workspace = true ai_onboarding.workspace = true anyhow.workspace = true assistant_context.workspace = true diff --git a/crates/agent_ui/src/acp/thread_view.rs b/crates/agent_ui/src/acp/thread_view.rs index 95f4f81205..7f5de9db5f 100644 --- a/crates/agent_ui/src/acp/thread_view.rs +++ b/crates/agent_ui/src/acp/thread_view.rs @@ -1,4 +1,4 @@ -use acp_thread::Plan; +use acp_thread::{AgentConnection, Plan}; use agent_servers::AgentServer; use std::cell::RefCell; use std::collections::BTreeMap; @@ -7,7 +7,7 @@ use std::rc::Rc; use std::sync::Arc; use std::time::Duration; -use agentic_coding_protocol::{self as acp}; +use agent_client_protocol as acp; use assistant_tool::ActionLog; use buffer_diff::BufferDiff; use collections::{HashMap, HashSet}; @@ -16,7 +16,6 @@ use editor::{ EditorStyle, MinimapVisibility, MultiBuffer, PathKey, }; use file_icons::FileIcons; -use futures::channel::oneshot; use gpui::{ Action, Animation, AnimationExt, App, BorderStyle, EdgesRefinement, Empty, Entity, EntityId, FocusHandle, Focusable, Hsla, Length, ListOffset, ListState, SharedString, StyleRefinement, @@ -39,8 +38,7 @@ use zed_actions::agent::{Chat, NextHistoryMessage, PreviousHistoryMessage}; use ::acp_thread::{ AcpThread, AcpThreadEvent, AgentThreadEntry, AssistantMessage, AssistantMessageChunk, Diff, - LoadError, MentionPath, ThreadStatus, ToolCall, ToolCallConfirmation, ToolCallContent, - ToolCallId, ToolCallStatus, + LoadError, MentionPath, ThreadStatus, ToolCall, ToolCallContent, ToolCallStatus, }; use crate::acp::completion_provider::{ContextPickerCompletionProvider, MentionSet}; @@ -64,12 +62,13 @@ pub struct AcpThreadView { last_error: Option>, list_state: ListState, auth_task: Option>, - expanded_tool_calls: HashSet, + expanded_tool_calls: HashSet, expanded_thinking_blocks: HashSet<(usize, usize)>, edits_expanded: bool, plan_expanded: bool, editor_expanded: bool, - message_history: Rc>>, + message_history: Rc>>>, + _cancel_task: Option>, } enum ThreadState { @@ -82,22 +81,16 @@ enum ThreadState { }, LoadError(LoadError), Unauthenticated { - thread: Entity, + connection: Rc, }, } -struct AlwaysAllowOption { - id: &'static str, - label: SharedString, - outcome: acp::ToolCallConfirmationOutcome, -} - impl AcpThreadView { pub fn new( agent: Rc, workspace: WeakEntity, project: Entity, - message_history: Rc>>, + message_history: Rc>>>, min_lines: usize, max_lines: Option, window: &mut Window, @@ -191,6 +184,7 @@ impl AcpThreadView { plan_expanded: false, editor_expanded: false, message_history, + _cancel_task: None, } } @@ -208,9 +202,9 @@ impl AcpThreadView { .map(|worktree| worktree.read(cx).abs_path()) .unwrap_or_else(|| paths::home_dir().as_path().into()); - let task = agent.new_thread(&root_dir, &project, cx); + let connect_task = agent.connect(&root_dir, &project, cx); let load_task = cx.spawn_in(window, async move |this, cx| { - let thread = match task.await { + let connection = match connect_task.await { Ok(thread) => thread, Err(err) => { this.update(cx, |this, cx| { @@ -222,48 +216,30 @@ impl AcpThreadView { } }; - let init_response = async { - let resp = thread - .read_with(cx, |thread, _cx| thread.initialize())? - .await?; - anyhow::Ok(resp) - }; - - let result = match init_response.await { + let result = match connection + .clone() + .new_thread(project.clone(), &root_dir, cx) + .await + { Err(e) => { let mut cx = cx.clone(); - if e.downcast_ref::().is_some() { - let child_status = thread - .update(&mut cx, |thread, _| thread.child_status()) - .ok() - .flatten(); - if let Some(child_status) = child_status { - match child_status.await { - Ok(_) => Err(e), - Err(e) => Err(e), - } - } else { - Err(e) - } + if e.downcast_ref::().is_some() { + this.update(&mut cx, |this, cx| { + this.thread_state = ThreadState::Unauthenticated { connection }; + cx.notify(); + }) + .ok(); + return; } else { Err(e) } } - Ok(response) => { - if !response.is_authenticated { - this.update(cx, |this, _| { - this.thread_state = ThreadState::Unauthenticated { thread }; - }) - .ok(); - return; - }; - Ok(()) - } + Ok(session_id) => Ok(session_id), }; this.update_in(cx, |this, window, cx| { match result { - Ok(()) => { + Ok(thread) => { let thread_subscription = cx.subscribe_in(&thread, window, Self::handle_thread_event); @@ -305,10 +281,10 @@ impl AcpThreadView { pub fn thread(&self) -> Option<&Entity> { match &self.thread_state { - ThreadState::Ready { thread, .. } | ThreadState::Unauthenticated { thread } => { - Some(thread) - } - ThreadState::Loading { .. } | ThreadState::LoadError(..) => None, + ThreadState::Ready { thread, .. } => Some(thread), + ThreadState::Unauthenticated { .. } + | ThreadState::Loading { .. } + | ThreadState::LoadError(..) => None, } } @@ -325,7 +301,7 @@ impl AcpThreadView { self.last_error.take(); if let Some(thread) = self.thread() { - thread.update(cx, |thread, cx| thread.cancel(cx)).detach(); + self._cancel_task = Some(thread.update(cx, |thread, cx| thread.cancel(cx))); } } @@ -362,7 +338,7 @@ impl AcpThreadView { self.last_error.take(); let mut ix = 0; - let mut chunks: Vec = Vec::new(); + let mut chunks: Vec = Vec::new(); let project = self.project.clone(); self.message_editor.update(cx, |editor, cx| { let text = editor.text(cx); @@ -374,12 +350,19 @@ impl AcpThreadView { { let crease_range = crease.range().to_offset(&snapshot.buffer_snapshot); if crease_range.start > ix { - chunks.push(acp::UserMessageChunk::Text { - text: text[ix..crease_range.start].to_string(), - }); + chunks.push(text[ix..crease_range.start].into()); } if let Some(abs_path) = project.read(cx).absolute_path(&project_path, cx) { - chunks.push(acp::UserMessageChunk::Path { path: abs_path }); + let path_str = abs_path.display().to_string(); + chunks.push(acp::ContentBlock::ResourceLink(acp::ResourceLink { + uri: path_str.clone(), + name: path_str, + annotations: None, + description: None, + mime_type: None, + size: None, + title: None, + })); } ix = crease_range.end; } @@ -388,9 +371,7 @@ impl AcpThreadView { if ix < text.len() { let last_chunk = text[ix..].trim(); if !last_chunk.is_empty() { - chunks.push(acp::UserMessageChunk::Text { - text: last_chunk.into(), - }); + chunks.push(last_chunk.into()); } } }) @@ -401,8 +382,7 @@ impl AcpThreadView { } let Some(thread) = self.thread() else { return }; - let message = acp::SendUserMessageParams { chunks }; - let task = thread.update(cx, |thread, cx| thread.send(message.clone(), cx)); + let task = thread.update(cx, |thread, cx| thread.send(chunks.clone(), cx)); cx.spawn(async move |this, cx| { let result = task.await; @@ -424,7 +404,7 @@ impl AcpThreadView { editor.remove_creases(mention_set.lock().drain(), cx) }); - self.message_history.borrow_mut().push(message); + self.message_history.borrow_mut().push(chunks); } fn previous_history_message( @@ -490,7 +470,7 @@ impl AcpThreadView { message_editor: Entity, mention_set: Arc>, project: Entity, - message: Option<&acp::SendUserMessageParams>, + message: Option<&Vec>, window: &mut Window, cx: &mut Context, ) -> bool { @@ -503,18 +483,19 @@ impl AcpThreadView { let mut text = String::new(); let mut mentions = Vec::new(); - for chunk in &message.chunks { + for chunk in message { match chunk { - acp::UserMessageChunk::Text { text: chunk } => { - text.push_str(&chunk); + acp::ContentBlock::Text(text_content) => { + text.push_str(&text_content.text); } - acp::UserMessageChunk::Path { path } => { + acp::ContentBlock::ResourceLink(resource_link) => { + let path = Path::new(&resource_link.uri); let start = text.len(); - let content = MentionPath::new(path).to_string(); + let content = MentionPath::new(&path).to_string(); text.push_str(&content); let end = text.len(); if let Some(project_path) = - project.read(cx).project_path_for_absolute_path(path, cx) + project.read(cx).project_path_for_absolute_path(&path, cx) { let filename: SharedString = path .file_name() @@ -525,6 +506,9 @@ impl AcpThreadView { mentions.push((start..end, project_path, filename)); } } + acp::ContentBlock::Image(_) + | acp::ContentBlock::Audio(_) + | acp::ContentBlock::Resource(_) => {} } } @@ -590,71 +574,79 @@ impl AcpThreadView { window: &mut Window, cx: &mut Context, ) { - let Some(multibuffer) = self.entry_diff_multibuffer(entry_ix, cx) else { + let Some(multibuffers) = self.entry_diff_multibuffers(entry_ix, cx) else { return; }; - if self.diff_editors.contains_key(&multibuffer.entity_id()) { - return; - } + let multibuffers = multibuffers.collect::>(); - let editor = cx.new(|cx| { - let mut editor = Editor::new( - EditorMode::Full { - scale_ui_elements_with_buffer_font_size: false, - show_active_line_background: false, - sized_by_content: true, - }, - multibuffer.clone(), - None, - window, - cx, - ); - editor.set_show_gutter(false, cx); - editor.disable_inline_diagnostics(); - editor.disable_expand_excerpt_buttons(cx); - editor.set_show_vertical_scrollbar(false, cx); - editor.set_minimap_visibility(MinimapVisibility::Disabled, window, cx); - editor.set_soft_wrap_mode(SoftWrap::None, cx); - editor.scroll_manager.set_forbid_vertical_scroll(true); - editor.set_show_indent_guides(false, cx); - editor.set_read_only(true); - editor.set_show_breakpoints(false, cx); - editor.set_show_code_actions(false, cx); - editor.set_show_git_diff_gutter(false, cx); - editor.set_expand_all_diff_hunks(cx); - editor.set_text_style_refinement(TextStyleRefinement { - font_size: Some( - TextSize::Small - .rems(cx) - .to_pixels(ThemeSettings::get_global(cx).agent_font_size(cx)) - .into(), - ), - ..Default::default() + for multibuffer in multibuffers { + if self.diff_editors.contains_key(&multibuffer.entity_id()) { + return; + } + + let editor = cx.new(|cx| { + let mut editor = Editor::new( + EditorMode::Full { + scale_ui_elements_with_buffer_font_size: false, + show_active_line_background: false, + sized_by_content: true, + }, + multibuffer.clone(), + None, + window, + cx, + ); + editor.set_show_gutter(false, cx); + editor.disable_inline_diagnostics(); + editor.disable_expand_excerpt_buttons(cx); + editor.set_show_vertical_scrollbar(false, cx); + editor.set_minimap_visibility(MinimapVisibility::Disabled, window, cx); + editor.set_soft_wrap_mode(SoftWrap::None, cx); + editor.scroll_manager.set_forbid_vertical_scroll(true); + editor.set_show_indent_guides(false, cx); + editor.set_read_only(true); + editor.set_show_breakpoints(false, cx); + editor.set_show_code_actions(false, cx); + editor.set_show_git_diff_gutter(false, cx); + editor.set_expand_all_diff_hunks(cx); + editor.set_text_style_refinement(TextStyleRefinement { + font_size: Some( + TextSize::Small + .rems(cx) + .to_pixels(ThemeSettings::get_global(cx).agent_font_size(cx)) + .into(), + ), + ..Default::default() + }); + editor }); - editor - }); - let entity_id = multibuffer.entity_id(); - cx.observe_release(&multibuffer, move |this, _, _| { - this.diff_editors.remove(&entity_id); - }) - .detach(); + let entity_id = multibuffer.entity_id(); + cx.observe_release(&multibuffer, move |this, _, _| { + this.diff_editors.remove(&entity_id); + }) + .detach(); - self.diff_editors.insert(entity_id, editor); + self.diff_editors.insert(entity_id, editor); + } } - fn entry_diff_multibuffer(&self, entry_ix: usize, cx: &App) -> Option> { + fn entry_diff_multibuffers( + &self, + entry_ix: usize, + cx: &App, + ) -> Option>> { let entry = self.thread()?.read(cx).entries().get(entry_ix)?; - entry.diff().map(|diff| diff.multibuffer.clone()) + Some(entry.diffs().map(|diff| diff.multibuffer.clone())) } fn authenticate(&mut self, window: &mut Window, cx: &mut Context) { - let Some(thread) = self.thread().cloned() else { + let ThreadState::Unauthenticated { ref connection } = self.thread_state else { return; }; self.last_error.take(); - let authenticate = thread.read(cx).authenticate(); + let authenticate = connection.authenticate(cx); self.auth_task = Some(cx.spawn_in(window, { let project = self.project.clone(); let agent = self.agent.clone(); @@ -684,15 +676,16 @@ impl AcpThreadView { fn authorize_tool_call( &mut self, - id: ToolCallId, - outcome: acp::ToolCallConfirmationOutcome, + tool_call_id: acp::ToolCallId, + option_id: acp::PermissionOptionId, + option_kind: acp::PermissionOptionKind, cx: &mut Context, ) { let Some(thread) = self.thread() else { return; }; thread.update(cx, |thread, cx| { - thread.authorize_tool_call(id, outcome, cx); + thread.authorize_tool_call(tool_call_id, option_id, option_kind, cx); }); cx.notify(); } @@ -719,10 +712,12 @@ impl AcpThreadView { .border_1() .border_color(cx.theme().colors().border) .text_xs() - .child(self.render_markdown( - message.content.clone(), - user_message_markdown_style(window, cx), - )), + .children(message.content.markdown().map(|md| { + self.render_markdown( + md.clone(), + user_message_markdown_style(window, cx), + ) + })), ) .into_any(), AgentThreadEntry::AssistantMessage(AssistantMessage { chunks }) => { @@ -730,20 +725,28 @@ impl AcpThreadView { let message_body = v_flex() .w_full() .gap_2p5() - .children(chunks.iter().enumerate().map(|(chunk_ix, chunk)| { - match chunk { - AssistantMessageChunk::Text { chunk } => self - .render_markdown(chunk.clone(), style.clone()) - .into_any_element(), - AssistantMessageChunk::Thought { chunk } => self.render_thinking_block( - index, - chunk_ix, - chunk.clone(), - window, - cx, - ), - } - })) + .children(chunks.iter().enumerate().filter_map( + |(chunk_ix, chunk)| match chunk { + AssistantMessageChunk::Message { block } => { + block.markdown().map(|md| { + self.render_markdown(md.clone(), style.clone()) + .into_any_element() + }) + } + AssistantMessageChunk::Thought { block } => { + block.markdown().map(|md| { + self.render_thinking_block( + index, + chunk_ix, + md.clone(), + window, + cx, + ) + .into_any_element() + }) + } + }, + )) .into_any(); v_flex() @@ -871,7 +874,7 @@ impl AcpThreadView { let status_icon = match &tool_call.status { ToolCallStatus::WaitingForConfirmation { .. } => None, ToolCallStatus::Allowed { - status: acp::ToolCallStatus::Running, + status: acp::ToolCallStatus::InProgress, .. } => Some( Icon::new(IconName::ArrowCircle) @@ -885,13 +888,13 @@ impl AcpThreadView { .into_any(), ), ToolCallStatus::Allowed { - status: acp::ToolCallStatus::Finished, + status: acp::ToolCallStatus::Completed, .. } => None, ToolCallStatus::Rejected | ToolCallStatus::Canceled | ToolCallStatus::Allowed { - status: acp::ToolCallStatus::Error, + status: acp::ToolCallStatus::Failed, .. } => Some( Icon::new(IconName::X) @@ -909,34 +912,9 @@ impl AcpThreadView { .any(|content| matches!(content, ToolCallContent::Diff { .. })), }; - let is_collapsible = tool_call.content.is_some() && !needs_confirmation; + let is_collapsible = !tool_call.content.is_empty() && !needs_confirmation; let is_open = !is_collapsible || self.expanded_tool_calls.contains(&tool_call.id); - let content = if is_open { - match &tool_call.status { - ToolCallStatus::WaitingForConfirmation { confirmation, .. } => { - Some(self.render_tool_call_confirmation( - tool_call.id, - confirmation, - tool_call.content.as_ref(), - window, - cx, - )) - } - ToolCallStatus::Allowed { .. } | ToolCallStatus::Canceled => { - tool_call.content.as_ref().map(|content| { - div() - .py_1p5() - .child(self.render_tool_call_content(content, window, cx)) - .into_any_element() - }) - } - ToolCallStatus::Rejected => None, - } - } else { - None - }; - v_flex() .when(needs_confirmation, |this| { this.rounded_lg() @@ -976,9 +954,17 @@ impl AcpThreadView { }) .gap_1p5() .child( - Icon::new(tool_call.icon) - .size(IconSize::Small) - .color(Color::Muted), + Icon::new(match tool_call.kind { + acp::ToolKind::Read => IconName::ToolRead, + acp::ToolKind::Edit => IconName::ToolPencil, + acp::ToolKind::Search => IconName::ToolSearch, + acp::ToolKind::Execute => IconName::ToolTerminal, + acp::ToolKind::Think => IconName::ToolBulb, + acp::ToolKind::Fetch => IconName::ToolWeb, + acp::ToolKind::Other => IconName::ToolHammer, + }) + .size(IconSize::Small) + .color(Color::Muted), ) .child(if tool_call.locations.len() == 1 { let name = tool_call.locations[0] @@ -1023,16 +1009,16 @@ impl AcpThreadView { .gap_0p5() .when(is_collapsible, |this| { this.child( - Disclosure::new(("expand", tool_call.id.0), is_open) + Disclosure::new(("expand", entry_ix), is_open) .opened_icon(IconName::ChevronUp) .closed_icon(IconName::ChevronDown) .on_click(cx.listener({ - let id = tool_call.id; + let id = tool_call.id.clone(); move |this: &mut Self, _, _, cx: &mut Context| { if is_open { this.expanded_tool_calls.remove(&id); } else { - this.expanded_tool_calls.insert(id); + this.expanded_tool_calls.insert(id.clone()); } cx.notify(); } @@ -1042,12 +1028,12 @@ impl AcpThreadView { .children(status_icon), ) .on_click(cx.listener({ - let id = tool_call.id; + let id = tool_call.id.clone(); move |this: &mut Self, _, _, cx: &mut Context| { if is_open { this.expanded_tool_calls.remove(&id); } else { - this.expanded_tool_calls.insert(id); + this.expanded_tool_calls.insert(id.clone()); } cx.notify(); } @@ -1055,7 +1041,7 @@ impl AcpThreadView { ) .when(is_open, |this| { this.child( - div() + v_flex() .text_xs() .when(is_collapsible, |this| { this.mt_1() @@ -1064,7 +1050,44 @@ impl AcpThreadView { .bg(cx.theme().colors().editor_background) .rounded_lg() }) - .children(content), + .map(|this| { + if is_open { + match &tool_call.status { + ToolCallStatus::WaitingForConfirmation { options, .. } => this + .children(tool_call.content.iter().map(|content| { + div() + .py_1p5() + .child( + self.render_tool_call_content( + content, window, cx, + ), + ) + .into_any_element() + })) + .child(self.render_permission_buttons( + options, + entry_ix, + tool_call.id.clone(), + cx, + )), + ToolCallStatus::Allowed { .. } | ToolCallStatus::Canceled => { + this.children(tool_call.content.iter().map(|content| { + div() + .py_1p5() + .child( + self.render_tool_call_content( + content, window, cx, + ), + ) + .into_any_element() + })) + } + ToolCallStatus::Rejected => this, + } + } else { + this + } + }), ) }) } @@ -1076,14 +1099,20 @@ impl AcpThreadView { cx: &Context, ) -> AnyElement { match content { - ToolCallContent::Markdown { markdown } => { - div() - .p_2() - .child(self.render_markdown( - markdown.clone(), - default_markdown_style(false, window, cx), - )) - .into_any_element() + ToolCallContent::ContentBlock { content } => { + if let Some(md) = content.markdown() { + div() + .p_2() + .child( + self.render_markdown( + md.clone(), + default_markdown_style(false, window, cx), + ), + ) + .into_any_element() + } else { + Empty.into_any_element() + } } ToolCallContent::Diff { diff: Diff { multibuffer, .. }, @@ -1092,223 +1121,53 @@ impl AcpThreadView { } } - fn render_tool_call_confirmation( + fn render_permission_buttons( &self, - tool_call_id: ToolCallId, - confirmation: &ToolCallConfirmation, - content: Option<&ToolCallContent>, - window: &Window, - cx: &Context, - ) -> AnyElement { - let confirmation_container = v_flex().mt_1().py_1p5(); - - match confirmation { - ToolCallConfirmation::Edit { description } => confirmation_container - .child( - div() - .px_2() - .children(description.clone().map(|description| { - self.render_markdown( - description, - default_markdown_style(false, window, cx), - ) - })), - ) - .children(content.map(|content| self.render_tool_call_content(content, window, cx))) - .child(self.render_confirmation_buttons( - &[AlwaysAllowOption { - id: "always_allow", - label: "Always Allow Edits".into(), - outcome: acp::ToolCallConfirmationOutcome::AlwaysAllow, - }], - tool_call_id, - cx, - )) - .into_any(), - ToolCallConfirmation::Execute { - command, - root_command, - description, - } => confirmation_container - .child(v_flex().px_2().pb_1p5().child(command.clone()).children( - description.clone().map(|description| { - self.render_markdown(description, default_markdown_style(false, window, cx)) - .on_url_click({ - let workspace = self.workspace.clone(); - move |text, window, cx| { - Self::open_link(text, &workspace, window, cx); - } - }) - }), - )) - .children(content.map(|content| self.render_tool_call_content(content, window, cx))) - .child(self.render_confirmation_buttons( - &[AlwaysAllowOption { - id: "always_allow", - label: format!("Always Allow {root_command}").into(), - outcome: acp::ToolCallConfirmationOutcome::AlwaysAllow, - }], - tool_call_id, - cx, - )) - .into_any(), - ToolCallConfirmation::Mcp { - server_name, - tool_name: _, - tool_display_name, - description, - } => confirmation_container - .child( - v_flex() - .px_2() - .pb_1p5() - .child(format!("{server_name} - {tool_display_name}")) - .children(description.clone().map(|description| { - self.render_markdown( - description, - default_markdown_style(false, window, cx), - ) - })), - ) - .children(content.map(|content| self.render_tool_call_content(content, window, cx))) - .child(self.render_confirmation_buttons( - &[ - AlwaysAllowOption { - id: "always_allow_server", - label: format!("Always Allow {server_name}").into(), - outcome: acp::ToolCallConfirmationOutcome::AlwaysAllowMcpServer, - }, - AlwaysAllowOption { - id: "always_allow_tool", - label: format!("Always Allow {tool_display_name}").into(), - outcome: acp::ToolCallConfirmationOutcome::AlwaysAllowTool, - }, - ], - tool_call_id, - cx, - )) - .into_any(), - ToolCallConfirmation::Fetch { description, urls } => confirmation_container - .child( - v_flex() - .px_2() - .pb_1p5() - .gap_1() - .children(urls.iter().map(|url| { - h_flex().child( - Button::new(url.clone(), url) - .icon(IconName::ArrowUpRight) - .icon_color(Color::Muted) - .icon_size(IconSize::XSmall) - .on_click({ - let url = url.clone(); - move |_, _, cx| cx.open_url(&url) - }), - ) - })) - .children(description.clone().map(|description| { - self.render_markdown( - description, - default_markdown_style(false, window, cx), - ) - })), - ) - .children(content.map(|content| self.render_tool_call_content(content, window, cx))) - .child(self.render_confirmation_buttons( - &[AlwaysAllowOption { - id: "always_allow", - label: "Always Allow".into(), - outcome: acp::ToolCallConfirmationOutcome::AlwaysAllow, - }], - tool_call_id, - cx, - )) - .into_any(), - ToolCallConfirmation::Other { description } => confirmation_container - .child(v_flex().px_2().pb_1p5().child(self.render_markdown( - description.clone(), - default_markdown_style(false, window, cx), - ))) - .children(content.map(|content| self.render_tool_call_content(content, window, cx))) - .child(self.render_confirmation_buttons( - &[AlwaysAllowOption { - id: "always_allow", - label: "Always Allow".into(), - outcome: acp::ToolCallConfirmationOutcome::AlwaysAllow, - }], - tool_call_id, - cx, - )) - .into_any(), - } - } - - fn render_confirmation_buttons( - &self, - always_allow_options: &[AlwaysAllowOption], - tool_call_id: ToolCallId, + options: &[acp::PermissionOption], + entry_ix: usize, + tool_call_id: acp::ToolCallId, cx: &Context, ) -> Div { h_flex() - .pt_1p5() + .py_1p5() .px_1p5() .gap_1() .justify_end() .border_t_1() .border_color(self.tool_card_border_color(cx)) - .when(self.agent.supports_always_allow(), |this| { - this.children(always_allow_options.into_iter().map(|always_allow_option| { - let outcome = always_allow_option.outcome; - Button::new( - (always_allow_option.id, tool_call_id.0), - always_allow_option.label.clone(), - ) - .icon(IconName::CheckDouble) + .children(options.iter().map(|option| { + let option_id = SharedString::from(option.id.0.clone()); + Button::new((option_id, entry_ix), option.label.clone()) + .map(|this| match option.kind { + acp::PermissionOptionKind::AllowOnce => { + this.icon(IconName::Check).icon_color(Color::Success) + } + acp::PermissionOptionKind::AllowAlways => { + this.icon(IconName::CheckDouble).icon_color(Color::Success) + } + acp::PermissionOptionKind::RejectOnce => { + this.icon(IconName::X).icon_color(Color::Error) + } + acp::PermissionOptionKind::RejectAlways => { + this.icon(IconName::X).icon_color(Color::Error) + } + }) .icon_position(IconPosition::Start) .icon_size(IconSize::XSmall) - .icon_color(Color::Success) .on_click(cx.listener({ - let id = tool_call_id; + let tool_call_id = tool_call_id.clone(); + let option_id = option.id.clone(); + let option_kind = option.kind; move |this, _, _, cx| { - this.authorize_tool_call(id, outcome, cx); + this.authorize_tool_call( + tool_call_id.clone(), + option_id.clone(), + option_kind, + cx, + ); } })) - })) - }) - .child( - Button::new(("allow", tool_call_id.0), "Allow") - .icon(IconName::Check) - .icon_position(IconPosition::Start) - .icon_size(IconSize::XSmall) - .icon_color(Color::Success) - .on_click(cx.listener({ - let id = tool_call_id; - move |this, _, _, cx| { - this.authorize_tool_call( - id, - acp::ToolCallConfirmationOutcome::Allow, - cx, - ); - } - })), - ) - .child( - Button::new(("reject", tool_call_id.0), "Reject") - .icon(IconName::X) - .icon_position(IconPosition::Start) - .icon_size(IconSize::XSmall) - .icon_color(Color::Error) - .on_click(cx.listener({ - let id = tool_call_id; - move |this, _, _, cx| { - this.authorize_tool_call( - id, - acp::ToolCallConfirmationOutcome::Reject, - cx, - ); - } - })), - ) + })) } fn render_diff_editor(&self, multibuffer: &Entity) -> AnyElement { @@ -2245,12 +2104,11 @@ impl AcpThreadView { .languages .language_for_name("Markdown"); - let (thread_summary, markdown) = match &self.thread_state { - ThreadState::Ready { thread, .. } | ThreadState::Unauthenticated { thread } => { - let thread = thread.read(cx); - (thread.title().to_string(), thread.to_markdown(cx)) - } - ThreadState::Loading { .. } | ThreadState::LoadError(..) => return Task::ready(Ok(())), + let (thread_summary, markdown) = if let Some(thread) = self.thread() { + let thread = thread.read(cx); + (thread.title().to_string(), thread.to_markdown(cx)) + } else { + return Task::ready(Ok(())); }; window.spawn(cx, async move |cx| { diff --git a/crates/agent_ui/src/agent_diff.rs b/crates/agent_ui/src/agent_diff.rs index e69664ce88..ec0a11f86b 100644 --- a/crates/agent_ui/src/agent_diff.rs +++ b/crates/agent_ui/src/agent_diff.rs @@ -1506,8 +1506,7 @@ impl AgentDiff { .read(cx) .entries() .last() - .and_then(|entry| entry.diff()) - .is_some() + .map_or(false, |entry| entry.diffs().next().is_some()) { self.update_reviewing_editors(workspace, window, cx); } @@ -1517,8 +1516,7 @@ impl AgentDiff { .read(cx) .entries() .get(*ix) - .and_then(|entry| entry.diff()) - .is_some() + .map_or(false, |entry| entry.diffs().next().is_some()) { self.update_reviewing_editors(workspace, window, cx); } diff --git a/crates/agent_ui/src/agent_panel.rs b/crates/agent_ui/src/agent_panel.rs index a0250816a0..4b3db4bc1d 100644 --- a/crates/agent_ui/src/agent_panel.rs +++ b/crates/agent_ui/src/agent_panel.rs @@ -440,7 +440,7 @@ pub struct AgentPanel { local_timezone: UtcOffset, active_view: ActiveView, acp_message_history: - Rc>>, + Rc>>>, previous_view: Option, history_store: Entity, history: Entity, diff --git a/crates/context_server/src/client.rs b/crates/context_server/src/client.rs index 6b24d9b136..8c5e7da0f1 100644 --- a/crates/context_server/src/client.rs +++ b/crates/context_server/src/client.rs @@ -1,6 +1,6 @@ use anyhow::{Context as _, Result, anyhow}; use collections::HashMap; -use futures::{FutureExt, StreamExt, channel::oneshot, select}; +use futures::{FutureExt, StreamExt, channel::oneshot, future, select}; use gpui::{AppContext as _, AsyncApp, BackgroundExecutor, Task}; use parking_lot::Mutex; use postage::barrier; @@ -10,15 +10,19 @@ use smol::channel; use std::{ fmt, path::PathBuf, + pin::pin, sync::{ Arc, atomic::{AtomicI32, Ordering::SeqCst}, }, time::{Duration, Instant}, }; -use util::TryFutureExt; +use util::{ResultExt, TryFutureExt}; -use crate::transport::{StdioTransport, Transport}; +use crate::{ + transport::{StdioTransport, Transport}, + types::{CancelledParams, ClientNotification, Notification as _, notifications::Cancelled}, +}; const JSON_RPC_VERSION: &str = "2.0"; const REQUEST_TIMEOUT: Duration = Duration::from_secs(60); @@ -32,6 +36,7 @@ pub const INTERNAL_ERROR: i32 = -32603; type ResponseHandler = Box)>; type NotificationHandler = Box; +type RequestHandler = Box; #[derive(Debug, Clone, Eq, PartialEq, Hash, Serialize, Deserialize)] #[serde(untagged)] @@ -78,6 +83,15 @@ pub struct Request<'a, T> { pub params: T, } +#[derive(Serialize, Deserialize)] +pub struct AnyRequest<'a> { + pub jsonrpc: &'a str, + pub id: RequestId, + pub method: &'a str, + #[serde(skip_serializing_if = "is_null_value")] + pub params: Option<&'a RawValue>, +} + #[derive(Serialize, Deserialize)] struct AnyResponse<'a> { jsonrpc: &'a str, @@ -176,15 +190,23 @@ impl Client { Arc::new(Mutex::new(HashMap::<_, NotificationHandler>::default())); let response_handlers = Arc::new(Mutex::new(Some(HashMap::<_, ResponseHandler>::default()))); + let request_handlers = Arc::new(Mutex::new(HashMap::<_, RequestHandler>::default())); let receive_input_task = cx.spawn({ let notification_handlers = notification_handlers.clone(); let response_handlers = response_handlers.clone(); + let request_handlers = request_handlers.clone(); let transport = transport.clone(); async move |cx| { - Self::handle_input(transport, notification_handlers, response_handlers, cx) - .log_err() - .await + Self::handle_input( + transport, + notification_handlers, + request_handlers, + response_handlers, + cx, + ) + .log_err() + .await } }); let receive_err_task = cx.spawn({ @@ -230,13 +252,24 @@ impl Client { async fn handle_input( transport: Arc, notification_handlers: Arc>>, + request_handlers: Arc>>, response_handlers: Arc>>>, cx: &mut AsyncApp, ) -> anyhow::Result<()> { let mut receiver = transport.receive(); while let Some(message) = receiver.next().await { - if let Ok(response) = serde_json::from_str::(&message) { + log::trace!("recv: {}", &message); + if let Ok(request) = serde_json::from_str::(&message) { + let mut request_handlers = request_handlers.lock(); + if let Some(handler) = request_handlers.get_mut(request.method) { + handler( + request.id, + request.params.unwrap_or(RawValue::NULL), + cx.clone(), + ); + } + } else if let Ok(response) = serde_json::from_str::(&message) { if let Some(handlers) = response_handlers.lock().as_mut() { if let Some(handler) = handlers.remove(&response.id) { handler(Ok(message.to_string())); @@ -247,6 +280,8 @@ impl Client { if let Some(handler) = notification_handlers.get_mut(notification.method.as_str()) { handler(notification.params.unwrap_or(Value::Null), cx.clone()); } + } else { + log::error!("Unhandled JSON from context_server: {}", message); } } @@ -294,6 +329,24 @@ impl Client { &self, method: &str, params: impl Serialize, + ) -> Result { + self.request_impl(method, params, None).await + } + + pub async fn cancellable_request( + &self, + method: &str, + params: impl Serialize, + cancel_rx: oneshot::Receiver<()>, + ) -> Result { + self.request_impl(method, params, Some(cancel_rx)).await + } + + pub async fn request_impl( + &self, + method: &str, + params: impl Serialize, + cancel_rx: Option>, ) -> Result { let id = self.next_id.fetch_add(1, SeqCst); let request = serde_json::to_string(&Request { @@ -330,6 +383,16 @@ impl Client { send?; let mut timeout = executor.timer(REQUEST_TIMEOUT).fuse(); + let mut cancel_fut = pin!( + match cancel_rx { + Some(rx) => future::Either::Left(async { + rx.await.log_err(); + }), + None => future::Either::Right(future::pending()), + } + .fuse() + ); + select! { response = rx.fuse() => { let elapsed = started.elapsed(); @@ -348,6 +411,16 @@ impl Client { Err(_) => anyhow::bail!("cancelled") } } + _ = cancel_fut => { + self.notify( + Cancelled::METHOD, + ClientNotification::Cancelled(CancelledParams { + request_id: RequestId::Int(id), + reason: None + }) + ).log_err(); + anyhow::bail!("Request cancelled") + } _ = timeout => { log::error!("cancelled csp request task for {method:?} id {id} which took over {:?}", REQUEST_TIMEOUT); anyhow::bail!("Context server request timeout"); diff --git a/crates/context_server/src/protocol.rs b/crates/context_server/src/protocol.rs index d8bbac60d6..7263f502fa 100644 --- a/crates/context_server/src/protocol.rs +++ b/crates/context_server/src/protocol.rs @@ -6,6 +6,9 @@ //! of messages. use anyhow::Result; +use futures::channel::oneshot; +use gpui::AsyncApp; +use serde_json::Value; use crate::client::Client; use crate::types::{self, Notification, Request}; @@ -95,7 +98,24 @@ impl InitializedContextServerProtocol { self.inner.request(T::METHOD, params).await } + pub async fn cancellable_request( + &self, + params: T::Params, + cancel_rx: oneshot::Receiver<()>, + ) -> Result { + self.inner + .cancellable_request(T::METHOD, params, cancel_rx) + .await + } + pub fn notify(&self, params: T::Params) -> Result<()> { self.inner.notify(T::METHOD, params) } + + pub fn on_notification(&self, method: &'static str, f: F) + where + F: 'static + Send + FnMut(Value, AsyncApp), + { + self.inner.on_notification(method, f); + } } diff --git a/crates/context_server/src/types.rs b/crates/context_server/src/types.rs index 4a6fdcabd3..f92c86aa3c 100644 --- a/crates/context_server/src/types.rs +++ b/crates/context_server/src/types.rs @@ -3,6 +3,8 @@ use serde::de::DeserializeOwned; use serde::{Deserialize, Serialize}; use url::Url; +use crate::client::RequestId; + pub const LATEST_PROTOCOL_VERSION: &str = "2025-03-26"; pub const VERSION_2024_11_05: &str = "2024-11-05"; @@ -100,6 +102,7 @@ pub mod notifications { notification!("notifications/initialized", Initialized, ()); notification!("notifications/progress", Progress, ProgressParams); notification!("notifications/message", Message, MessageParams); + notification!("notifications/cancelled", Cancelled, CancelledParams); notification!( "notifications/resources/updated", ResourcesUpdated, @@ -617,11 +620,14 @@ pub enum ClientNotification { Initialized, Progress(ProgressParams), RootsListChanged, - Cancelled { - request_id: String, - #[serde(skip_serializing_if = "Option::is_none")] - reason: Option, - }, + Cancelled(CancelledParams), +} + +#[derive(Debug, Serialize, Deserialize)] +pub struct CancelledParams { + pub request_id: RequestId, + #[serde(skip_serializing_if = "Option::is_none")] + pub reason: Option, } #[derive(Debug, Serialize, Deserialize)] From 1f7ff956bcef31f93db4b9841737c0bc893bafc9 Mon Sep 17 00:00:00 2001 From: Peter Tripp Date: Thu, 24 Jul 2025 14:29:28 -0400 Subject: [PATCH 037/893] Fix environment loading with nushell (#35002) Closes https://github.com/zed-industries/zed/issues/34739 I believe this is a regression introduced here: - https://github.com/zed-industries/zed/pull/33599 Release Notes: - Fixed a regression with loading environment variables in nushell --- crates/util/src/shell_env.rs | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-) diff --git a/crates/util/src/shell_env.rs b/crates/util/src/shell_env.rs index 21f6096f19..ed6c8a23cc 100644 --- a/crates/util/src/shell_env.rs +++ b/crates/util/src/shell_env.rs @@ -18,10 +18,13 @@ pub fn capture(directory: &std::path::Path) -> Result format!(">[1={}]", ENV_OUTPUT_FD), // `[1=0]` - _ => format!(">&{}", ENV_OUTPUT_FD), // `>&0` + const FD_STDIN: std::os::fd::RawFd = 0; + const FD_STDOUT: std::os::fd::RawFd = 1; + + let (fd_num, redir) = match shell_name { + Some("rc") => (FD_STDIN, format!(">[1={}]", FD_STDIN)), // `[1=0]` + Some("nu") => (FD_STDOUT, "".to_string()), + _ => (FD_STDIN, format!(">&{}", FD_STDIN)), // `>&0` }; command.stdin(Stdio::null()); command.stdout(Stdio::piped()); @@ -48,7 +51,7 @@ pub fn capture(directory: &std::path::Path) -> Result Date: Thu, 24 Jul 2025 11:44:26 -0700 Subject: [PATCH 038/893] Increase the number of parallel request handlers per connection (#35046) Discussed this with @ConradIrwin. The problem we're having with collab is that a bunch of LSP requests take a really long time to resolve, particularly `RefreshCodeLens`. But Those requests are sharing a limited amount of concurrency that we've allocated for all message traffic on one connection. That said, there's not _that_ many concurrent requests made at any one time. The burst traffic seems to top out in the low hundreds for these requests. So let's just expand the amount of space in the queue to accommodate these long-running requests while we work on upgrading our cloud infrastructure. Release Notes: - N/A Co-authored-by: finn --- crates/collab/src/rpc.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/collab/src/rpc.rs b/crates/collab/src/rpc.rs index 0735b08e89..5c5de2f36e 100644 --- a/crates/collab/src/rpc.rs +++ b/crates/collab/src/rpc.rs @@ -829,7 +829,7 @@ impl Server { // This arrangement ensures we will attempt to process earlier messages first, but fall // back to processing messages arrived later in the spirit of making progress. let mut foreground_message_handlers = FuturesUnordered::new(); - let concurrent_handlers = Arc::new(Semaphore::new(256)); + let concurrent_handlers = Arc::new(Semaphore::new(512)); loop { let next_message = async { let permit = concurrent_handlers.clone().acquire_owned().await.unwrap(); From 707df516647f07c05e0c04e67ee032279b3d8afa Mon Sep 17 00:00:00 2001 From: Peter Tripp Date: Thu, 24 Jul 2025 15:39:13 -0400 Subject: [PATCH 039/893] Fix environment loading with tcsh (#35054) Closes https://github.com/zed-industries/zed/issues/34973 Fixes an issue where environment variables were not loaded when the user's shell was tcsh and instead a file named `0` was dumped in the current working directory with a copy of your environment variables as json. Follow-up to: - https://github.com/zed-industries/zed/pull/35002 - https://github.com/zed-industries/zed/pull/33599 Release Notes: - Fixed a regression with loading environment variables in nushell --- crates/util/src/shell_env.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/util/src/shell_env.rs b/crates/util/src/shell_env.rs index ed6c8a23cc..d737999e45 100644 --- a/crates/util/src/shell_env.rs +++ b/crates/util/src/shell_env.rs @@ -23,7 +23,7 @@ pub fn capture(directory: &std::path::Path) -> Result (FD_STDIN, format!(">[1={}]", FD_STDIN)), // `[1=0]` - Some("nu") => (FD_STDOUT, "".to_string()), + Some("nu") | Some("tcsh") => (FD_STDOUT, "".to_string()), _ => (FD_STDIN, format!(">&{}", FD_STDIN)), // `>&0` }; command.stdin(Stdio::null()); From 66acc2698aa39468ea9a0beecc8892cc57f1a91f Mon Sep 17 00:00:00 2001 From: Zachary Hamm Date: Thu, 24 Jul 2025 17:25:21 -0500 Subject: [PATCH 040/893] git_hosting_providers: Support GitHub remote URLs that start with a slash (#34134) Remote URLs like `git@github.com:/zed-industries/zed` are valid git remotes, but currently Zed does not parse them correctly. The result is invalid "permalink" generation, and presumably other bugs anywhere that git remote urls are required for the current repository. This ensures Zed will parse those URLs correctly. Release Notes: - Improved support for GitHub remote urls where the username/organization is preceded by an extra `/` to match the behavior of `git`, `gh` and `github.com`. Co-authored-by: Peter Tripp --- .../src/providers/github.rs | 22 ++++++++++++++++++- 1 file changed, 21 insertions(+), 1 deletion(-) diff --git a/crates/git_hosting_providers/src/providers/github.rs b/crates/git_hosting_providers/src/providers/github.rs index 649b2f30ae..30f8d058a7 100644 --- a/crates/git_hosting_providers/src/providers/github.rs +++ b/crates/git_hosting_providers/src/providers/github.rs @@ -159,7 +159,11 @@ impl GitHostingProvider for Github { } let mut path_segments = url.path_segments()?; - let owner = path_segments.next()?; + let mut owner = path_segments.next()?; + if owner.is_empty() { + owner = path_segments.next()?; + } + let repo = path_segments.next()?.trim_end_matches(".git"); Some(ParsedGitRemote { @@ -244,6 +248,22 @@ mod tests { use super::*; + #[test] + fn test_remote_url_with_root_slash() { + let remote_url = "git@github.com:/zed-industries/zed"; + let parsed_remote = Github::public_instance() + .parse_remote_url(remote_url) + .unwrap(); + + assert_eq!( + parsed_remote, + ParsedGitRemote { + owner: "zed-industries".into(), + repo: "zed".into(), + } + ); + } + #[test] fn test_invalid_self_hosted_remote_url() { let remote_url = "git@github.com:zed-industries/zed.git"; From f78a1123873526bb112183033641d9077b47981c Mon Sep 17 00:00:00 2001 From: Smit Barmase Date: Fri, 25 Jul 2025 05:13:09 +0530 Subject: [PATCH 041/893] gpui: Add `scroll_to_item_with_offset` to `UniformListScrollState` (#35064) Previously we had `ScrollStrategy::ToPosition(usize)` which lets you define the offset where you want to scroll that item to. This is the same as `ScrollStrategy::Top` but imagine some space reserved at the top. This PR removes `ScrollStrategy::ToPosition` in favor of `scroll_to_item_with_offset` which is the method to do the same. The reason to add this method is that now not just `ScrollStrategy::Top` but `ScrollStrategy::Center` can also uses this offset to center the item in the remaining unreserved space. ```rs // Before scroll_handle.scroll_to_item(index, ScrollStrategy::ToPosition(offset)); // After scroll_handle.scroll_to_item_with_offset(index, ScrollStrategy::Top, offset); // New! Centers item skipping first x items scroll_handle.scroll_to_item_with_offset(index, ScrollStrategy::Center, offset); ``` This will be useful for follow up PR. Release Notes: - N/A --- crates/gpui/src/elements/uniform_list.rs | 64 ++++++++++++++++------- crates/project_panel/src/project_panel.rs | 5 +- 2 files changed, 45 insertions(+), 24 deletions(-) diff --git a/crates/gpui/src/elements/uniform_list.rs b/crates/gpui/src/elements/uniform_list.rs index e80656a078..cdf90d4eb8 100644 --- a/crates/gpui/src/elements/uniform_list.rs +++ b/crates/gpui/src/elements/uniform_list.rs @@ -88,15 +88,24 @@ pub enum ScrollStrategy { /// May not be possible if there's not enough list items above the item scrolled to: /// in this case, the element will be placed at the closest possible position. Center, - /// Scrolls the element to be at the given item index from the top of the viewport. - ToPosition(usize), +} + +#[derive(Clone, Copy, Debug)] +#[allow(missing_docs)] +pub struct DeferredScrollToItem { + /// The item index to scroll to + pub item_index: usize, + /// The scroll strategy to use + pub strategy: ScrollStrategy, + /// The offset in number of items + pub offset: usize, } #[derive(Clone, Debug, Default)] #[allow(missing_docs)] pub struct UniformListScrollState { pub base_handle: ScrollHandle, - pub deferred_scroll_to_item: Option<(usize, ScrollStrategy)>, + pub deferred_scroll_to_item: Option, /// Size of the item, captured during last layout. pub last_item_size: Option, /// Whether the list was vertically flipped during last layout. @@ -126,7 +135,24 @@ impl UniformListScrollHandle { /// Scroll the list to the given item index. pub fn scroll_to_item(&self, ix: usize, strategy: ScrollStrategy) { - self.0.borrow_mut().deferred_scroll_to_item = Some((ix, strategy)); + self.0.borrow_mut().deferred_scroll_to_item = Some(DeferredScrollToItem { + item_index: ix, + strategy, + offset: 0, + }); + } + + /// Scroll the list to the given item index with an offset. + /// + /// For ScrollStrategy::Top, the item will be placed at the offset position from the top. + /// + /// For ScrollStrategy::Center, the item will be centered between offset and the last visible item. + pub fn scroll_to_item_with_offset(&self, ix: usize, strategy: ScrollStrategy, offset: usize) { + self.0.borrow_mut().deferred_scroll_to_item = Some(DeferredScrollToItem { + item_index: ix, + strategy, + offset, + }); } /// Check if the list is flipped vertically. @@ -139,7 +165,8 @@ impl UniformListScrollHandle { pub fn logical_scroll_top_index(&self) -> usize { let this = self.0.borrow(); this.deferred_scroll_to_item - .map(|(ix, _)| ix) + .as_ref() + .map(|deferred| deferred.item_index) .unwrap_or_else(|| this.base_handle.logical_scroll_top().0) } @@ -320,7 +347,8 @@ impl Element for UniformList { scroll_offset.x = Pixels::ZERO; } - if let Some((mut ix, scroll_strategy)) = shared_scroll_to_item { + if let Some(deferred_scroll) = shared_scroll_to_item { + let mut ix = deferred_scroll.item_index; if y_flipped { ix = self.item_count.saturating_sub(ix + 1); } @@ -329,23 +357,28 @@ impl Element for UniformList { let item_top = item_height * ix + padding.top; let item_bottom = item_top + item_height; let scroll_top = -updated_scroll_offset.y; + let offset_pixels = item_height * deferred_scroll.offset; let mut scrolled_to_top = false; - if item_top < scroll_top + padding.top { + + if item_top < scroll_top + padding.top + offset_pixels { scrolled_to_top = true; - updated_scroll_offset.y = -(item_top) + padding.top; + updated_scroll_offset.y = -(item_top) + padding.top + offset_pixels; } else if item_bottom > scroll_top + list_height - padding.bottom { scrolled_to_top = true; updated_scroll_offset.y = -(item_bottom - list_height) - padding.bottom; } - match scroll_strategy { + match deferred_scroll.strategy { ScrollStrategy::Top => {} ScrollStrategy::Center => { if scrolled_to_top { let item_center = item_top + item_height / 2.0; - let target_scroll_top = item_center - list_height / 2.0; - if item_top < scroll_top + let viewport_height = list_height - offset_pixels; + let viewport_center = offset_pixels + viewport_height / 2.0; + let target_scroll_top = item_center - viewport_center; + + if item_top < scroll_top + offset_pixels || item_bottom > scroll_top + list_height { updated_scroll_offset.y = -target_scroll_top @@ -355,15 +388,6 @@ impl Element for UniformList { } } } - ScrollStrategy::ToPosition(sticky_index) => { - let target_y_in_viewport = item_height * sticky_index; - let target_scroll_top = item_top - target_y_in_viewport; - let max_scroll_top = - (content_height - list_height).max(Pixels::ZERO); - let new_scroll_top = - target_scroll_top.clamp(Pixels::ZERO, max_scroll_top); - updated_scroll_offset.y = -new_scroll_top; - } } scroll_offset = *updated_scroll_offset } diff --git a/crates/project_panel/src/project_panel.rs b/crates/project_panel/src/project_panel.rs index 76be97e393..dd680981fc 100644 --- a/crates/project_panel/src/project_panel.rs +++ b/crates/project_panel/src/project_panel.rs @@ -4207,10 +4207,7 @@ impl ProjectPanel { this.marked_entries.clear(); if is_sticky { if let Some((_, _, index)) = this.index_for_entry(entry_id, worktree_id) { - let strategy = sticky_index - .map(ScrollStrategy::ToPosition) - .unwrap_or(ScrollStrategy::Top); - this.scroll_handle.scroll_to_item(index, strategy); + this.scroll_handle.scroll_to_item_with_offset(index, ScrollStrategy::Top, sticky_index.unwrap_or(0)); cx.notify(); // move down by 1px so that clicked item // don't count as sticky anymore From 4ee52433ae606b095a9054162060e59d33874e16 Mon Sep 17 00:00:00 2001 From: Daniel Sauble Date: Thu, 24 Jul 2025 17:00:59 -0700 Subject: [PATCH 042/893] Do not subtract gutter margin twice from the editor width (#34564) Closes #33176 In auto-height layouts, horizontal autoscroll can occur right before soft wrapping is triggered. This seems to be caused by gutter margin being subtracted twice from the editor width. If we subtract gutter width only once, the horizontal autoscroll behavior goes away. Before: https://github.com/user-attachments/assets/03b6687e-3c0e-4b34-8e07-a228bcc6f798 After: https://github.com/user-attachments/assets/84e54088-b5bd-4259-a193-d9fcf32cd3a7 Release Notes: - Fixes issue with auto-height layouts where horizontal autoscroll is triggered right before text wraps --------- Co-authored-by: MrSubidubi --- crates/editor/src/element.rs | 62 +++++++++++------------------------- 1 file changed, 18 insertions(+), 44 deletions(-) diff --git a/crates/editor/src/element.rs b/crates/editor/src/element.rs index 5fd6b028f4..7e77f113ac 100644 --- a/crates/editor/src/element.rs +++ b/crates/editor/src/element.rs @@ -7944,17 +7944,11 @@ impl Element for EditorElement { right: right_margin, }; - // Offset the content_bounds from the text_bounds by the gutter margin (which - // is roughly half a character wide) to make hit testing work more like how we want. - let content_offset = point(editor_margins.gutter.margin, Pixels::ZERO); - - let editor_content_width = editor_width - content_offset.x; - snapshot = self.editor.update(cx, |editor, cx| { editor.last_bounds = Some(bounds); editor.gutter_dimensions = gutter_dimensions; editor.set_visible_line_count(bounds.size.height / line_height, window, cx); - editor.set_visible_column_count(editor_content_width / em_advance); + editor.set_visible_column_count(editor_width / em_advance); if matches!( editor.mode, @@ -7966,10 +7960,10 @@ impl Element for EditorElement { let wrap_width = match editor.soft_wrap_mode(cx) { SoftWrap::GitDiff => None, SoftWrap::None => Some(wrap_width_for(MAX_LINE_LEN as u32 / 2)), - SoftWrap::EditorWidth => Some(editor_content_width), + SoftWrap::EditorWidth => Some(editor_width), SoftWrap::Column(column) => Some(wrap_width_for(column)), SoftWrap::Bounded(column) => { - Some(editor_content_width.min(wrap_width_for(column))) + Some(editor_width.min(wrap_width_for(column))) } }; @@ -7994,13 +7988,12 @@ impl Element for EditorElement { HitboxBehavior::Normal, ); + // Offset the content_bounds from the text_bounds by the gutter margin (which + // is roughly half a character wide) to make hit testing work more like how we want. + let content_offset = point(editor_margins.gutter.margin, Pixels::ZERO); let content_origin = text_hitbox.origin + content_offset; - let editor_text_bounds = - Bounds::from_corners(content_origin, bounds.bottom_right()); - - let height_in_lines = editor_text_bounds.size.height / line_height; - + let height_in_lines = bounds.size.height / line_height; let max_row = snapshot.max_point().row().as_f32(); // The max scroll position for the top of the window @@ -8384,7 +8377,6 @@ impl Element for EditorElement { glyph_grid_cell, size(longest_line_width, max_row.as_f32() * line_height), longest_line_blame_width, - editor_width, EditorSettings::get_global(cx), ); @@ -8456,7 +8448,7 @@ impl Element for EditorElement { MultiBufferRow(end_anchor.to_point(&snapshot.buffer_snapshot).row); let scroll_max = point( - ((scroll_width - editor_content_width) / em_advance).max(0.0), + ((scroll_width - editor_width) / em_advance).max(0.0), max_scroll_top, ); @@ -8468,7 +8460,7 @@ impl Element for EditorElement { if needs_horizontal_autoscroll.0 && let Some(new_scroll_position) = editor.autoscroll_horizontally( start_row, - editor_content_width, + editor_width, scroll_width, em_advance, &line_layouts, @@ -9049,7 +9041,6 @@ impl ScrollbarLayoutInformation { glyph_grid_cell: Size, document_size: Size, longest_line_blame_width: Pixels, - editor_width: Pixels, settings: &EditorSettings, ) -> Self { let vertical_overscroll = match settings.scroll_beyond_last_line { @@ -9060,19 +9051,11 @@ impl ScrollbarLayoutInformation { } }; - let right_margin = if document_size.width + longest_line_blame_width >= editor_width { - glyph_grid_cell.width - } else { - px(0.0) - }; - - let overscroll = size(right_margin + longest_line_blame_width, vertical_overscroll); - - let scroll_range = document_size + overscroll; + let overscroll = size(longest_line_blame_width, vertical_overscroll); ScrollbarLayoutInformation { editor_bounds, - scroll_range, + scroll_range: document_size + overscroll, glyph_grid_cell, } } @@ -9177,7 +9160,7 @@ struct EditorScrollbars { impl EditorScrollbars { pub fn from_scrollbar_axes( - settings_visibility: ScrollbarAxes, + show_scrollbar: ScrollbarAxes, layout_information: &ScrollbarLayoutInformation, content_offset: gpui::Point, scroll_position: gpui::Point, @@ -9215,22 +9198,13 @@ impl EditorScrollbars { }; let mut create_scrollbar_layout = |axis| { - settings_visibility - .along(axis) + let viewport_size = viewport_size.along(axis); + let scroll_range = scroll_range.along(axis); + + // We always want a vertical scrollbar track for scrollbar diagnostic visibility. + (show_scrollbar.along(axis) + && (axis == ScrollbarAxis::Vertical || scroll_range > viewport_size)) .then(|| { - ( - viewport_size.along(axis) - content_offset.along(axis), - scroll_range.along(axis), - ) - }) - .filter(|(viewport_size, scroll_range)| { - // The scrollbar should only be rendered if the content does - // not entirely fit into the editor - // However, this only applies to the horizontal scrollbar, as information about the - // vertical scrollbar layout is always needed for scrollbar diagnostics. - axis != ScrollbarAxis::Horizontal || viewport_size < scroll_range - }) - .map(|(viewport_size, scroll_range)| { ScrollbarLayout::new( window.insert_hitbox(scrollbar_bounds_for(axis), HitboxBehavior::Normal), viewport_size, From 6e4f7470413ab709f766793cd23c0aa65700cf99 Mon Sep 17 00:00:00 2001 From: Smit Barmase Date: Fri, 25 Jul 2025 06:21:38 +0530 Subject: [PATCH 043/893] project_panel: Fix autoscroll to treat entries behind sticky items as out of viewport (#35067) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Closes #34831 Autoscroll centers items only if they’re out of viewport. Before this PR, entry behind sticky items was not considered out of viewport, and hence actions like `reveal in project panel` or focusing buffer would not autoscroll that entry into the view in that case. This PR fixes that by using recently added `scroll_to_item_with_offset` in https://github.com/zed-industries/zed/pull/35064. Release Notes: - Fixed issue where `pane: reveal in project panel` action was not working if the entry was behind sticky items. --- crates/project_panel/src/project_panel.rs | 17 ++++++++++++++--- 1 file changed, 14 insertions(+), 3 deletions(-) diff --git a/crates/project_panel/src/project_panel.rs b/crates/project_panel/src/project_panel.rs index dd680981fc..05e6bfe4df 100644 --- a/crates/project_panel/src/project_panel.rs +++ b/crates/project_panel/src/project_panel.rs @@ -114,6 +114,7 @@ pub struct ProjectPanel { mouse_down: bool, hover_expand_task: Option>, previous_drag_position: Option>, + sticky_items_count: usize, } struct DragTargetEntry { @@ -572,6 +573,9 @@ impl ProjectPanel { if project_panel_settings.hide_root != new_settings.hide_root { this.update_visible_entries(None, cx); } + if project_panel_settings.sticky_scroll && !new_settings.sticky_scroll { + this.sticky_items_count = 0; + } project_panel_settings = new_settings; this.update_diagnostics(cx); cx.notify(); @@ -615,6 +619,7 @@ impl ProjectPanel { mouse_down: false, hover_expand_task: None, previous_drag_position: None, + sticky_items_count: 0, }; this.update_visible_entries(None, cx); @@ -2267,8 +2272,11 @@ impl ProjectPanel { fn autoscroll(&mut self, cx: &mut Context) { if let Some((_, _, index)) = self.selection.and_then(|s| self.index_for_selection(s)) { - self.scroll_handle - .scroll_to_item(index, ScrollStrategy::Center); + self.scroll_handle.scroll_to_item_with_offset( + index, + ScrollStrategy::Center, + self.sticky_items_count, + ); cx.notify(); } } @@ -5344,7 +5352,10 @@ impl Render for ProjectPanel { items }, |this, marker_entry, window, cx| { - this.render_sticky_entries(marker_entry, window, cx) + let sticky_entries = + this.render_sticky_entries(marker_entry, window, cx); + this.sticky_items_count = sticky_entries.len(); + sticky_entries }, ); list.with_decoration(if show_indent_guides { From a0f2019b6f031c0933022797932f8ca90871cfb4 Mon Sep 17 00:00:00 2001 From: morgankrey Date: Thu, 24 Jul 2025 19:18:40 -0600 Subject: [PATCH 044/893] Add sales tax to docs (#35059) Release Notes: - N/A --- docs/src/ai/billing.md | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/docs/src/ai/billing.md b/docs/src/ai/billing.md index c49bacd883..e8587e1fef 100644 --- a/docs/src/ai/billing.md +++ b/docs/src/ai/billing.md @@ -25,3 +25,12 @@ From Stripe’s secure portal, you can download all current and historical invoi You can update your payment method, company name, address, and tax information through the billing portal. Please note that changes to billing information will **only** affect future invoices — **we cannot modify historical invoices**. + +## Sales Tax {#sales-tax} + +Zed partners with [Sphere](https://www.getsphere.com/) to calculate indirect tax rate for invoices, based on customer location and the product being sold. Tax is listed as a separate line item on invoices, based preferentially on your billing address, followed by the card issue country known to Stripe. + +If you have a VAT/GST ID, you can add it at [zed.dev/account](https://zed.dev/account) by clicking "Manage" on your subscription. Check the box that denotes you as a business. + +Please note that changes to VAT/GST IDs and address will **only** affect future invoices — **we cannot modify historical invoices**. +Questions or issues can be directed to billing-support@zed.dev. From b446d66be780c5b73f5b429033055e950edf27e2 Mon Sep 17 00:00:00 2001 From: morgankrey Date: Thu, 24 Jul 2025 19:25:39 -0600 Subject: [PATCH 045/893] Telemetry docs cleanup (#35060) Release Notes: - N/A --- docs/src/telemetry.md | 13 ++++++++++--- 1 file changed, 10 insertions(+), 3 deletions(-) diff --git a/docs/src/telemetry.md b/docs/src/telemetry.md index 20018b920a..7f5994be0c 100644 --- a/docs/src/telemetry.md +++ b/docs/src/telemetry.md @@ -22,8 +22,9 @@ The telemetry settings can also be configured via the welcome screen, which can Telemetry is sent from the application to our servers. Data is proxied through our servers to enable us to easily switch analytics services. We currently use: - [Axiom](https://axiom.co): Cloud-monitoring service - stores diagnostic events -- [Snowflake](https://snowflake.com): Business Intelligence platform - stores both diagnostic and metric events -- [Metabase](https://www.metabase.com): Dashboards - dashboards built around data pulled from Snowflake +- [Snowflake](https://snowflake.com): Data warehouse - stores both diagnostic and metric events +- [Hex](https://www.hex.tech): Dashboards and data exploration - accesses data stored in Snowflake +- [Amplitude](https://www.amplitude.com): Dashboards and data exploration - accesses data stored in Snowflake ## Types of Telemetry @@ -33,7 +34,7 @@ Diagnostic events include debug information (stack traces) from crash reports. R You can see what data is sent when a panic occurs by inspecting the `Panic` struct in [crates/telemetry_events/src/telemetry_events.rs](https://github.com/zed-industries/zed/blob/main/crates/telemetry_events/src/telemetry_events.rs) in the Zed repo. You can find additional information in the [Debugging Crashes](./development/debugging-crashes.md) documentation. -### Usage Data (Metrics) {#metrics} +### Client-Side Usage Data {#client-metrics} To improve Zed and understand how it is being used in the wild, Zed optionally collects usage data like the following: @@ -50,6 +51,12 @@ You can audit the metrics data that Zed has reported by running the command {#ac You can see the full list of the event types and exactly the data sent for each by inspecting the `Event` enum and the associated structs in [crates/telemetry_events/src/telemetry_events.rs](https://github.com/zed-industries/zed/blob/main/crates/telemetry_events/src/telemetry_events.rs) in the Zed repository. +### Server-Side Usage Data {#metrics} + +When using Zed's hosted services, we may collect, generate, and Process data to allow us to support users and improve our hosted offering. Examples include metadata around rate limiting and billing metrics/token usage. Zed does not persistently store user content or use user content to evaluate and/or improve our AI features, unless it is explicitly shared with Zed, and we have a zero-data retention agreement with Anthropic. + +You can see more about our stance on data collection (and that any prompt data shared with Zed is explicitly opt-in) at [AI Improvement](./ai/ai-improvement.md). + ## Concerns and Questions If you have concerns about telemetry, please feel free to [open an issue](https://github.com/zed-industries/zed/issues/new/choose). From 15c9da4ea4e740faa22cf7c740bed666fdf9ff4a Mon Sep 17 00:00:00 2001 From: Agus Zubiaga Date: Thu, 24 Jul 2025 23:19:20 -0300 Subject: [PATCH 046/893] Add ability to register tools in `McpServer` (#35068) Makes it easier to add tools to a server by implementing a trait Release Notes: - N/A --- crates/agent_servers/src/claude.rs | 11 +- crates/agent_servers/src/claude/mcp_server.rs | 418 +++++++++--------- crates/context_server/src/listener.rs | 217 ++++++++- crates/context_server/src/types.rs | 6 +- 4 files changed, 408 insertions(+), 244 deletions(-) diff --git a/crates/agent_servers/src/claude.rs b/crates/agent_servers/src/claude.rs index 5f35b4af73..d63d8c43cf 100644 --- a/crates/agent_servers/src/claude.rs +++ b/crates/agent_servers/src/claude.rs @@ -2,6 +2,7 @@ mod mcp_server; pub mod tools; use collections::HashMap; +use context_server::listener::McpServerTool; use project::Project; use settings::SettingsStore; use smol::process::Child; @@ -332,10 +333,16 @@ async fn spawn_claude( &format!( "mcp__{}__{}", mcp_server::SERVER_NAME, - mcp_server::PERMISSION_TOOL + mcp_server::PermissionTool::NAME, ), "--allowedTools", - "mcp__zed__Read,mcp__zed__Edit", + &format!( + "mcp__{}__{},mcp__{}__{}", + mcp_server::SERVER_NAME, + mcp_server::EditTool::NAME, + mcp_server::SERVER_NAME, + mcp_server::ReadTool::NAME + ), "--disallowedTools", "Read,Edit", ]) diff --git a/crates/agent_servers/src/claude/mcp_server.rs b/crates/agent_servers/src/claude/mcp_server.rs index 0a39a02931..4272a972dc 100644 --- a/crates/agent_servers/src/claude/mcp_server.rs +++ b/crates/agent_servers/src/claude/mcp_server.rs @@ -1,49 +1,24 @@ use std::path::PathBuf; +use crate::claude::tools::{ClaudeTool, EditToolParams, ReadToolParams}; use acp_thread::AcpThread; use agent_client_protocol as acp; use anyhow::{Context, Result}; use collections::HashMap; +use context_server::listener::{McpServerTool, ToolResponse}; use context_server::types::{ - CallToolParams, CallToolResponse, Implementation, InitializeParams, InitializeResponse, - ListToolsResponse, ProtocolVersion, ServerCapabilities, Tool, ToolAnnotations, - ToolResponseContent, ToolsCapabilities, requests, + Implementation, InitializeParams, InitializeResponse, ProtocolVersion, ServerCapabilities, + ToolAnnotations, ToolResponseContent, ToolsCapabilities, requests, }; -use gpui::{App, AsyncApp, Entity, Task, WeakEntity}; +use gpui::{App, AsyncApp, Task, WeakEntity}; use schemars::JsonSchema; use serde::{Deserialize, Serialize}; -use crate::claude::tools::{ClaudeTool, EditToolParams, ReadToolParams}; - pub struct ClaudeZedMcpServer { server: context_server::listener::McpServer, } pub const SERVER_NAME: &str = "zed"; -pub const READ_TOOL: &str = "Read"; -pub const EDIT_TOOL: &str = "Edit"; -pub const PERMISSION_TOOL: &str = "Confirmation"; - -#[derive(Deserialize, JsonSchema, Debug)] -struct PermissionToolParams { - tool_name: String, - input: serde_json::Value, - tool_use_id: Option, -} - -#[derive(Serialize)] -#[serde(rename_all = "camelCase")] -struct PermissionToolResponse { - behavior: PermissionToolBehavior, - updated_input: serde_json::Value, -} - -#[derive(Serialize)] -#[serde(rename_all = "snake_case")] -enum PermissionToolBehavior { - Allow, - Deny, -} impl ClaudeZedMcpServer { pub async fn new( @@ -52,9 +27,15 @@ impl ClaudeZedMcpServer { ) -> Result { let mut mcp_server = context_server::listener::McpServer::new(cx).await?; mcp_server.handle_request::(Self::handle_initialize); - mcp_server.handle_request::(Self::handle_list_tools); - mcp_server.handle_request::(move |request, cx| { - Self::handle_call_tool(request, thread_rx.clone(), cx) + + mcp_server.add_tool(PermissionTool { + thread_rx: thread_rx.clone(), + }); + mcp_server.add_tool(ReadTool { + thread_rx: thread_rx.clone(), + }); + mcp_server.add_tool(EditTool { + thread_rx: thread_rx.clone(), }); Ok(Self { server: mcp_server }) @@ -96,193 +77,6 @@ impl ClaudeZedMcpServer { }) }) } - - fn handle_list_tools(_: (), cx: &App) -> Task> { - cx.foreground_executor().spawn(async move { - Ok(ListToolsResponse { - tools: vec![ - Tool { - name: PERMISSION_TOOL.into(), - input_schema: schemars::schema_for!(PermissionToolParams).into(), - description: None, - annotations: None, - }, - Tool { - name: READ_TOOL.into(), - input_schema: schemars::schema_for!(ReadToolParams).into(), - description: Some("Read the contents of a file. In sessions with mcp__zed__Read always use it instead of Read as it contains the most up-to-date contents.".to_string()), - annotations: Some(ToolAnnotations { - title: Some("Read file".to_string()), - read_only_hint: Some(true), - destructive_hint: Some(false), - open_world_hint: Some(false), - // if time passes the contents might change, but it's not going to do anything different - // true or false seem too strong, let's try a none. - idempotent_hint: None, - }), - }, - Tool { - name: EDIT_TOOL.into(), - input_schema: schemars::schema_for!(EditToolParams).into(), - description: Some("Edits a file. In sessions with mcp__zed__Edit always use it instead of Edit as it will show the diff to the user better.".to_string()), - annotations: Some(ToolAnnotations { - title: Some("Edit file".to_string()), - read_only_hint: Some(false), - destructive_hint: Some(false), - open_world_hint: Some(false), - idempotent_hint: Some(false), - }), - }, - ], - next_cursor: None, - meta: None, - }) - }) - } - - fn handle_call_tool( - request: CallToolParams, - mut thread_rx: watch::Receiver>, - cx: &App, - ) -> Task> { - cx.spawn(async move |cx| { - let Some(thread) = thread_rx.recv().await?.upgrade() else { - anyhow::bail!("Thread closed"); - }; - - if request.name.as_str() == PERMISSION_TOOL { - let input = - serde_json::from_value(request.arguments.context("Arguments required")?)?; - - let result = Self::handle_permissions_tool_call(input, thread, cx).await?; - Ok(CallToolResponse { - content: vec![ToolResponseContent::Text { - text: serde_json::to_string(&result)?, - }], - is_error: None, - meta: None, - }) - } else if request.name.as_str() == READ_TOOL { - let input = - serde_json::from_value(request.arguments.context("Arguments required")?)?; - - let content = Self::handle_read_tool_call(input, thread, cx).await?; - Ok(CallToolResponse { - content, - is_error: None, - meta: None, - }) - } else if request.name.as_str() == EDIT_TOOL { - let input = - serde_json::from_value(request.arguments.context("Arguments required")?)?; - - Self::handle_edit_tool_call(input, thread, cx).await?; - Ok(CallToolResponse { - content: vec![], - is_error: None, - meta: None, - }) - } else { - anyhow::bail!("Unsupported tool"); - } - }) - } - - fn handle_read_tool_call( - ReadToolParams { - abs_path, - offset, - limit, - }: ReadToolParams, - thread: Entity, - cx: &AsyncApp, - ) -> Task>> { - cx.spawn(async move |cx| { - let content = thread - .update(cx, |thread, cx| { - thread.read_text_file(abs_path, offset, limit, false, cx) - })? - .await?; - - Ok(vec![ToolResponseContent::Text { text: content }]) - }) - } - - fn handle_edit_tool_call( - params: EditToolParams, - thread: Entity, - cx: &AsyncApp, - ) -> Task> { - cx.spawn(async move |cx| { - let content = thread - .update(cx, |threads, cx| { - threads.read_text_file(params.abs_path.clone(), None, None, true, cx) - })? - .await?; - - let new_content = content.replace(¶ms.old_text, ¶ms.new_text); - if new_content == content { - return Err(anyhow::anyhow!("The old_text was not found in the content")); - } - - thread - .update(cx, |threads, cx| { - threads.write_text_file(params.abs_path, new_content, cx) - })? - .await?; - - Ok(()) - }) - } - - fn handle_permissions_tool_call( - params: PermissionToolParams, - thread: Entity, - cx: &AsyncApp, - ) -> Task> { - cx.spawn(async move |cx| { - let claude_tool = ClaudeTool::infer(¶ms.tool_name, params.input.clone()); - - let tool_call_id = - acp::ToolCallId(params.tool_use_id.context("Tool ID required")?.into()); - - let allow_option_id = acp::PermissionOptionId("allow".into()); - let reject_option_id = acp::PermissionOptionId("reject".into()); - - let chosen_option = thread - .update(cx, |thread, cx| { - thread.request_tool_call_permission( - claude_tool.as_acp(tool_call_id), - vec![ - acp::PermissionOption { - id: allow_option_id.clone(), - label: "Allow".into(), - kind: acp::PermissionOptionKind::AllowOnce, - }, - acp::PermissionOption { - id: reject_option_id, - label: "Reject".into(), - kind: acp::PermissionOptionKind::RejectOnce, - }, - ], - cx, - ) - })? - .await?; - - if chosen_option == allow_option_id { - Ok(PermissionToolResponse { - behavior: PermissionToolBehavior::Allow, - updated_input: params.input, - }) - } else { - Ok(PermissionToolResponse { - behavior: PermissionToolBehavior::Deny, - updated_input: params.input, - }) - } - }) - } } #[derive(Serialize)] @@ -299,3 +93,187 @@ pub struct McpServerConfig { #[serde(skip_serializing_if = "Option::is_none")] pub env: Option>, } + +// Tools + +#[derive(Clone)] +pub struct PermissionTool { + thread_rx: watch::Receiver>, +} + +#[derive(Deserialize, JsonSchema, Debug)] +pub struct PermissionToolParams { + tool_name: String, + input: serde_json::Value, + tool_use_id: Option, +} + +#[derive(Serialize)] +#[serde(rename_all = "camelCase")] +pub struct PermissionToolResponse { + behavior: PermissionToolBehavior, + updated_input: serde_json::Value, +} + +#[derive(Serialize)] +#[serde(rename_all = "snake_case")] +enum PermissionToolBehavior { + Allow, + Deny, +} + +impl McpServerTool for PermissionTool { + type Input = PermissionToolParams; + const NAME: &'static str = "Confirmation"; + + fn description(&self) -> &'static str { + "Request permission for tool calls" + } + + async fn run(&self, input: Self::Input, cx: &mut AsyncApp) -> Result { + let mut thread_rx = self.thread_rx.clone(); + let Some(thread) = thread_rx.recv().await?.upgrade() else { + anyhow::bail!("Thread closed"); + }; + + let claude_tool = ClaudeTool::infer(&input.tool_name, input.input.clone()); + let tool_call_id = acp::ToolCallId(input.tool_use_id.context("Tool ID required")?.into()); + let allow_option_id = acp::PermissionOptionId("allow".into()); + let reject_option_id = acp::PermissionOptionId("reject".into()); + + let chosen_option = thread + .update(cx, |thread, cx| { + thread.request_tool_call_permission( + claude_tool.as_acp(tool_call_id), + vec![ + acp::PermissionOption { + id: allow_option_id.clone(), + label: "Allow".into(), + kind: acp::PermissionOptionKind::AllowOnce, + }, + acp::PermissionOption { + id: reject_option_id.clone(), + label: "Reject".into(), + kind: acp::PermissionOptionKind::RejectOnce, + }, + ], + cx, + ) + })? + .await?; + + let response = if chosen_option == allow_option_id { + PermissionToolResponse { + behavior: PermissionToolBehavior::Allow, + updated_input: input.input, + } + } else { + PermissionToolResponse { + behavior: PermissionToolBehavior::Deny, + updated_input: input.input, + } + }; + + Ok(ToolResponse { + content: vec![ToolResponseContent::Text { + text: serde_json::to_string(&response)?, + }], + structured_content: None, + }) + } +} + +#[derive(Clone)] +pub struct ReadTool { + thread_rx: watch::Receiver>, +} + +impl McpServerTool for ReadTool { + type Input = ReadToolParams; + const NAME: &'static str = "Read"; + + fn description(&self) -> &'static str { + "Read the contents of a file. In sessions with mcp__zed__Read always use it instead of Read as it contains the most up-to-date contents." + } + + fn annotations(&self) -> ToolAnnotations { + ToolAnnotations { + title: Some("Read file".to_string()), + read_only_hint: Some(true), + destructive_hint: Some(false), + open_world_hint: Some(false), + idempotent_hint: None, + } + } + + async fn run(&self, input: Self::Input, cx: &mut AsyncApp) -> Result { + let mut thread_rx = self.thread_rx.clone(); + let Some(thread) = thread_rx.recv().await?.upgrade() else { + anyhow::bail!("Thread closed"); + }; + + let content = thread + .update(cx, |thread, cx| { + thread.read_text_file(input.abs_path, input.offset, input.limit, false, cx) + })? + .await?; + + Ok(ToolResponse { + content: vec![ToolResponseContent::Text { text: content }], + structured_content: None, + }) + } +} + +#[derive(Clone)] +pub struct EditTool { + thread_rx: watch::Receiver>, +} + +impl McpServerTool for EditTool { + type Input = EditToolParams; + const NAME: &'static str = "Edit"; + + fn description(&self) -> &'static str { + "Edits a file. In sessions with mcp__zed__Edit always use it instead of Edit as it will show the diff to the user better." + } + + fn annotations(&self) -> ToolAnnotations { + ToolAnnotations { + title: Some("Edit file".to_string()), + read_only_hint: Some(false), + destructive_hint: Some(false), + open_world_hint: Some(false), + idempotent_hint: Some(false), + } + } + + async fn run(&self, input: Self::Input, cx: &mut AsyncApp) -> Result { + let mut thread_rx = self.thread_rx.clone(); + let Some(thread) = thread_rx.recv().await?.upgrade() else { + anyhow::bail!("Thread closed"); + }; + + let content = thread + .update(cx, |thread, cx| { + thread.read_text_file(input.abs_path.clone(), None, None, true, cx) + })? + .await?; + + let new_content = content.replace(&input.old_text, &input.new_text); + if new_content == content { + return Err(anyhow::anyhow!("The old_text was not found in the content")); + } + + thread + .update(cx, |thread, cx| { + thread.write_text_file(input.abs_path, new_content, cx) + })? + .await?; + + Ok(ToolResponse { + content: vec![], + structured_content: None, + }) + } +} diff --git a/crates/context_server/src/listener.rs b/crates/context_server/src/listener.rs index 9295ad979c..087395a961 100644 --- a/crates/context_server/src/listener.rs +++ b/crates/context_server/src/listener.rs @@ -9,6 +9,8 @@ use futures::{ }; use gpui::{App, AppContext, AsyncApp, Task}; use net::async_net::{UnixListener, UnixStream}; +use schemars::JsonSchema; +use serde::de::DeserializeOwned; use serde_json::{json, value::RawValue}; use smol::stream::StreamExt; use std::{ @@ -20,16 +22,28 @@ use util::ResultExt; use crate::{ client::{CspResult, RequestId, Response}, - types::Request, + types::{ + CallToolParams, CallToolResponse, ListToolsResponse, Request, Tool, ToolAnnotations, + ToolResponseContent, + requests::{CallTool, ListTools}, + }, }; pub struct McpServer { socket_path: PathBuf, - handlers: Rc>>, + tools: Rc>>, + handlers: Rc>>, _server_task: Task<()>, } -type McpHandler = Box>, &App) -> Task>; +struct RegisteredTool { + tool: Tool, + handler: ToolHandler, +} + +type ToolHandler = + Box, &mut AsyncApp) -> Task>>; +type RequestHandler = Box>, &App) -> Task>; impl McpServer { pub fn new(cx: &AsyncApp) -> Task> { @@ -43,12 +57,14 @@ impl McpServer { cx.spawn(async move |cx| { let (temp_dir, socket_path, listener) = task.await?; + let tools = Rc::new(RefCell::new(HashMap::default())); let handlers = Rc::new(RefCell::new(HashMap::default())); let server_task = cx.spawn({ + let tools = tools.clone(); let handlers = handlers.clone(); async move |cx| { while let Ok((stream, _)) = listener.accept().await { - Self::serve_connection(stream, handlers.clone(), cx); + Self::serve_connection(stream, tools.clone(), handlers.clone(), cx); } drop(temp_dir) } @@ -56,11 +72,40 @@ impl McpServer { Ok(Self { socket_path, _server_task: server_task, - handlers: handlers.clone(), + tools, + handlers: handlers, }) }) } + pub fn add_tool(&mut self, tool: T) { + let registered_tool = RegisteredTool { + tool: Tool { + name: T::NAME.into(), + description: Some(tool.description().into()), + input_schema: schemars::schema_for!(T::Input).into(), + annotations: Some(tool.annotations()), + }, + handler: Box::new({ + let tool = tool.clone(); + move |input_value, cx| { + let input = match input_value { + Some(input) => serde_json::from_value(input), + None => serde_json::from_value(serde_json::Value::Null), + }; + + let tool = tool.clone(); + match input { + Ok(input) => cx.spawn(async move |cx| tool.run(input, cx).await), + Err(err) => Task::ready(Err(err.into())), + } + } + }), + }; + + self.tools.borrow_mut().insert(T::NAME, registered_tool); + } + pub fn handle_request( &mut self, f: impl Fn(R::Params, &App) -> Task> + 'static, @@ -120,7 +165,8 @@ impl McpServer { fn serve_connection( stream: UnixStream, - handlers: Rc>>, + tools: Rc>>, + handlers: Rc>>, cx: &mut AsyncApp, ) { let (read, write) = smol::io::split(stream); @@ -135,7 +181,13 @@ impl McpServer { let Some(request_id) = request.id.clone() else { continue; }; - if let Some(handler) = handlers.borrow().get(&request.method.as_ref()) { + + if request.method == CallTool::METHOD { + Self::handle_call_tool(request_id, request.params, &tools, &outgoing_tx, cx) + .await; + } else if request.method == ListTools::METHOD { + Self::handle_list_tools(request.id.unwrap(), &tools, &outgoing_tx); + } else if let Some(handler) = handlers.borrow().get(&request.method.as_ref()) { let outgoing_tx = outgoing_tx.clone(); if let Some(task) = cx @@ -149,25 +201,122 @@ impl McpServer { .detach(); } } else { - outgoing_tx - .unbounded_send( - serde_json::to_string(&Response::<()> { - jsonrpc: "2.0", - id: request.id.unwrap(), - value: CspResult::Error(Some(crate::client::Error { - message: format!("unhandled method {}", request.method), - code: -32601, - })), - }) - .unwrap(), - ) - .ok(); + Self::send_err( + request_id, + format!("unhandled method {}", request.method), + &outgoing_tx, + ); } } }) .detach(); } + fn handle_list_tools( + request_id: RequestId, + tools: &Rc>>, + outgoing_tx: &UnboundedSender, + ) { + let response = ListToolsResponse { + tools: tools.borrow().values().map(|t| t.tool.clone()).collect(), + next_cursor: None, + meta: None, + }; + + outgoing_tx + .unbounded_send( + serde_json::to_string(&Response { + jsonrpc: "2.0", + id: request_id, + value: CspResult::Ok(Some(response)), + }) + .unwrap_or_default(), + ) + .ok(); + } + + async fn handle_call_tool( + request_id: RequestId, + params: Option>, + tools: &Rc>>, + outgoing_tx: &UnboundedSender, + cx: &mut AsyncApp, + ) { + let result: Result = match params.as_ref() { + Some(params) => serde_json::from_str(params.get()), + None => serde_json::from_value(serde_json::Value::Null), + }; + + match result { + Ok(params) => { + if let Some(tool) = tools.borrow().get(¶ms.name.as_ref()) { + let outgoing_tx = outgoing_tx.clone(); + + let task = (tool.handler)(params.arguments, cx); + cx.spawn(async move |_| { + let response = match task.await { + Ok(result) => CallToolResponse { + content: result.content, + is_error: Some(false), + meta: None, + structured_content: result.structured_content, + }, + Err(err) => CallToolResponse { + content: vec![ToolResponseContent::Text { + text: err.to_string(), + }], + is_error: Some(true), + meta: None, + structured_content: None, + }, + }; + + outgoing_tx + .unbounded_send( + serde_json::to_string(&Response { + jsonrpc: "2.0", + id: request_id, + value: CspResult::Ok(Some(response)), + }) + .unwrap_or_default(), + ) + .ok(); + }) + .detach(); + } else { + Self::send_err( + request_id, + format!("Tool not found: {}", params.name), + &outgoing_tx, + ); + } + } + Err(err) => { + Self::send_err(request_id, err.to_string(), &outgoing_tx); + } + } + } + + fn send_err( + request_id: RequestId, + message: impl Into, + outgoing_tx: &UnboundedSender, + ) { + outgoing_tx + .unbounded_send( + serde_json::to_string(&Response::<()> { + jsonrpc: "2.0", + id: request_id, + value: CspResult::Error(Some(crate::client::Error { + message: message.into(), + code: -32601, + })), + }) + .unwrap(), + ) + .ok(); + } + async fn handle_io( mut outgoing_rx: UnboundedReceiver, incoming_tx: UnboundedSender, @@ -216,6 +365,34 @@ impl McpServer { } } +pub trait McpServerTool { + type Input: DeserializeOwned + JsonSchema; + const NAME: &'static str; + + fn description(&self) -> &'static str; + + fn annotations(&self) -> ToolAnnotations { + ToolAnnotations { + title: None, + read_only_hint: None, + destructive_hint: None, + idempotent_hint: None, + open_world_hint: None, + } + } + + fn run( + &self, + input: Self::Input, + cx: &mut AsyncApp, + ) -> impl Future>; +} + +pub struct ToolResponse { + pub content: Vec, + pub structured_content: Option, +} + #[derive(Serialize, Deserialize)] struct RawRequest { #[serde(skip_serializing_if = "Option::is_none")] diff --git a/crates/context_server/src/types.rs b/crates/context_server/src/types.rs index f92c86aa3c..c95d9008bc 100644 --- a/crates/context_server/src/types.rs +++ b/crates/context_server/src/types.rs @@ -495,7 +495,7 @@ pub struct RootsCapabilities { pub list_changed: Option, } -#[derive(Debug, Serialize, Deserialize)] +#[derive(Clone, Debug, Serialize, Deserialize)] #[serde(rename_all = "camelCase")] pub struct Tool { pub name: String, @@ -506,7 +506,7 @@ pub struct Tool { pub annotations: Option, } -#[derive(Debug, Serialize, Deserialize)] +#[derive(Clone, Debug, Serialize, Deserialize)] #[serde(rename_all = "camelCase")] pub struct ToolAnnotations { /// A human-readable title for the tool. @@ -679,6 +679,8 @@ pub struct CallToolResponse { pub is_error: Option, #[serde(rename = "_meta", skip_serializing_if = "Option::is_none")] pub meta: Option>, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub structured_content: Option, } #[derive(Debug, Serialize, Deserialize)] From af0c909924d5b5b46432847fce2afb4bc8d78ee2 Mon Sep 17 00:00:00 2001 From: Agus Zubiaga Date: Thu, 24 Jul 2025 23:57:18 -0300 Subject: [PATCH 047/893] McpServerTool output schema (#35069) Add an `Output` associated type to `McpServerTool`, so that we can include its schema in `tools/list`. Release Notes: - N/A --- crates/agent_servers/src/claude/mcp_server.rs | 30 +++++++++++--- crates/context_server/src/listener.rs | 40 +++++++++++++++---- crates/context_server/src/types.rs | 2 + 3 files changed, 59 insertions(+), 13 deletions(-) diff --git a/crates/agent_servers/src/claude/mcp_server.rs b/crates/agent_servers/src/claude/mcp_server.rs index 4272a972dc..a320a6d37f 100644 --- a/crates/agent_servers/src/claude/mcp_server.rs +++ b/crates/agent_servers/src/claude/mcp_server.rs @@ -124,13 +124,19 @@ enum PermissionToolBehavior { impl McpServerTool for PermissionTool { type Input = PermissionToolParams; + type Output = (); + const NAME: &'static str = "Confirmation"; fn description(&self) -> &'static str { "Request permission for tool calls" } - async fn run(&self, input: Self::Input, cx: &mut AsyncApp) -> Result { + async fn run( + &self, + input: Self::Input, + cx: &mut AsyncApp, + ) -> Result> { let mut thread_rx = self.thread_rx.clone(); let Some(thread) = thread_rx.recv().await?.upgrade() else { anyhow::bail!("Thread closed"); @@ -178,7 +184,7 @@ impl McpServerTool for PermissionTool { content: vec![ToolResponseContent::Text { text: serde_json::to_string(&response)?, }], - structured_content: None, + structured_content: (), }) } } @@ -190,6 +196,8 @@ pub struct ReadTool { impl McpServerTool for ReadTool { type Input = ReadToolParams; + type Output = (); + const NAME: &'static str = "Read"; fn description(&self) -> &'static str { @@ -206,7 +214,11 @@ impl McpServerTool for ReadTool { } } - async fn run(&self, input: Self::Input, cx: &mut AsyncApp) -> Result { + async fn run( + &self, + input: Self::Input, + cx: &mut AsyncApp, + ) -> Result> { let mut thread_rx = self.thread_rx.clone(); let Some(thread) = thread_rx.recv().await?.upgrade() else { anyhow::bail!("Thread closed"); @@ -220,7 +232,7 @@ impl McpServerTool for ReadTool { Ok(ToolResponse { content: vec![ToolResponseContent::Text { text: content }], - structured_content: None, + structured_content: (), }) } } @@ -232,6 +244,8 @@ pub struct EditTool { impl McpServerTool for EditTool { type Input = EditToolParams; + type Output = (); + const NAME: &'static str = "Edit"; fn description(&self) -> &'static str { @@ -248,7 +262,11 @@ impl McpServerTool for EditTool { } } - async fn run(&self, input: Self::Input, cx: &mut AsyncApp) -> Result { + async fn run( + &self, + input: Self::Input, + cx: &mut AsyncApp, + ) -> Result> { let mut thread_rx = self.thread_rx.clone(); let Some(thread) = thread_rx.recv().await?.upgrade() else { anyhow::bail!("Thread closed"); @@ -273,7 +291,7 @@ impl McpServerTool for EditTool { Ok(ToolResponse { content: vec![], - structured_content: None, + structured_content: (), }) } } diff --git a/crates/context_server/src/listener.rs b/crates/context_server/src/listener.rs index 087395a961..192f530816 100644 --- a/crates/context_server/src/listener.rs +++ b/crates/context_server/src/listener.rs @@ -41,8 +41,12 @@ struct RegisteredTool { handler: ToolHandler, } -type ToolHandler = - Box, &mut AsyncApp) -> Task>>; +type ToolHandler = Box< + dyn Fn( + Option, + &mut AsyncApp, + ) -> Task>>, +>; type RequestHandler = Box>, &App) -> Task>; impl McpServer { @@ -79,11 +83,19 @@ impl McpServer { } pub fn add_tool(&mut self, tool: T) { + let output_schema = schemars::schema_for!(T::Output); + let unit_schema = schemars::schema_for!(()); + let registered_tool = RegisteredTool { tool: Tool { name: T::NAME.into(), description: Some(tool.description().into()), input_schema: schemars::schema_for!(T::Input).into(), + output_schema: if output_schema == unit_schema { + None + } else { + Some(output_schema.into()) + }, annotations: Some(tool.annotations()), }, handler: Box::new({ @@ -96,7 +108,15 @@ impl McpServer { let tool = tool.clone(); match input { - Ok(input) => cx.spawn(async move |cx| tool.run(input, cx).await), + Ok(input) => cx.spawn(async move |cx| { + let output = tool.run(input, cx).await?; + + Ok(ToolResponse { + content: output.content, + structured_content: serde_json::to_value(output.structured_content) + .unwrap_or_default(), + }) + }), Err(err) => Task::ready(Err(err.into())), } } @@ -259,7 +279,11 @@ impl McpServer { content: result.content, is_error: Some(false), meta: None, - structured_content: result.structured_content, + structured_content: if result.structured_content.is_null() { + None + } else { + Some(result.structured_content) + }, }, Err(err) => CallToolResponse { content: vec![ToolResponseContent::Text { @@ -367,6 +391,8 @@ impl McpServer { pub trait McpServerTool { type Input: DeserializeOwned + JsonSchema; + type Output: Serialize + JsonSchema; + const NAME: &'static str; fn description(&self) -> &'static str; @@ -385,12 +411,12 @@ pub trait McpServerTool { &self, input: Self::Input, cx: &mut AsyncApp, - ) -> impl Future>; + ) -> impl Future>>; } -pub struct ToolResponse { +pub struct ToolResponse { pub content: Vec, - pub structured_content: Option, + pub structured_content: T, } #[derive(Serialize, Deserialize)] diff --git a/crates/context_server/src/types.rs b/crates/context_server/src/types.rs index c95d9008bc..cd97ff95bc 100644 --- a/crates/context_server/src/types.rs +++ b/crates/context_server/src/types.rs @@ -502,6 +502,8 @@ pub struct Tool { #[serde(skip_serializing_if = "Option::is_none")] pub description: Option, pub input_schema: serde_json::Value, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub output_schema: Option, #[serde(skip_serializing_if = "Option::is_none")] pub annotations: Option, } From 631f9a1b31c16b53e65126163094622f54669960 Mon Sep 17 00:00:00 2001 From: Piotr Osiewicz <24362066+osiewicz@users.noreply.github.com> Date: Fri, 25 Jul 2025 13:18:19 +0200 Subject: [PATCH 048/893] worktree: Improve performance with large # of repositories (#35052) In this PR we've reworked how git status updates are processed. Most notable change is moving the processing into a background thread (and splitting it across multiple background workers). We believe it is safe to do so, as worktree events are not deterministic (fs updates are not guaranteed to come in any order etc), so I've figured that git store should not be overly order-reliant anyways. Note that this PR does not solve perf issues wholesale - other parts of the system are still slow to process stuff (which I plan to nuke soon). Related to #34302 Release Notes: - Improved Zed's performance in projects with large # of repositories --------- Co-authored-by: Anthony Eid --- crates/project/src/git_store.rs | 132 ++++++++++++++---- crates/project/src/git_store/git_traversal.rs | 48 +++++-- 2 files changed, 142 insertions(+), 38 deletions(-) diff --git a/crates/project/src/git_store.rs b/crates/project/src/git_store.rs index eb16446daf..d131b6dd41 100644 --- a/crates/project/src/git_store.rs +++ b/crates/project/src/git_store.rs @@ -14,9 +14,10 @@ use collections::HashMap; pub use conflict_set::{ConflictRegion, ConflictSet, ConflictSetSnapshot, ConflictSetUpdate}; use fs::Fs; use futures::{ - FutureExt, StreamExt as _, + FutureExt, StreamExt, channel::{mpsc, oneshot}, future::{self, Shared}, + stream::FuturesOrdered, }; use git::{ BuildPermalinkParams, GitHostingProviderRegistry, WORK_DIRECTORY_REPO_PATH, @@ -63,8 +64,8 @@ use sum_tree::{Edit, SumTree, TreeSet}; use text::{Bias, BufferId}; use util::{ResultExt, debug_panic, post_inc}; use worktree::{ - File, PathKey, PathProgress, PathSummary, PathTarget, UpdatedGitRepositoriesSet, - UpdatedGitRepository, Worktree, + File, PathChange, PathKey, PathProgress, PathSummary, PathTarget, ProjectEntryId, + UpdatedGitRepositoriesSet, UpdatedGitRepository, Worktree, }; pub struct GitStore { @@ -1083,27 +1084,26 @@ impl GitStore { match event { WorktreeStoreEvent::WorktreeUpdatedEntries(worktree_id, updated_entries) => { - let mut paths_by_git_repo = HashMap::<_, Vec<_>>::default(); - for (relative_path, _, _) in updated_entries.iter() { - let Some((repo, repo_path)) = self.repository_and_path_for_project_path( - &(*worktree_id, relative_path.clone()).into(), - cx, - ) else { - continue; - }; - paths_by_git_repo.entry(repo).or_default().push(repo_path) - } - - for (repo, paths) in paths_by_git_repo { - repo.update(cx, |repo, cx| { - repo.paths_changed( - paths, - downstream - .as_ref() - .map(|downstream| downstream.updates_tx.clone()), - cx, - ); - }); + if let Some(worktree) = self + .worktree_store + .read(cx) + .worktree_for_id(*worktree_id, cx) + { + let paths_by_git_repo = + self.process_updated_entries(&worktree, updated_entries, cx); + let downstream = downstream + .as_ref() + .map(|downstream| downstream.updates_tx.clone()); + cx.spawn(async move |_, cx| { + let paths_by_git_repo = paths_by_git_repo.await; + for (repo, paths) in paths_by_git_repo { + repo.update(cx, |repo, cx| { + repo.paths_changed(paths, downstream.clone(), cx); + }) + .ok(); + } + }) + .detach(); } } WorktreeStoreEvent::WorktreeUpdatedGitRepositories(worktree_id, changed_repos) => { @@ -2191,6 +2191,80 @@ impl GitStore { .map(|(id, repo)| (*id, repo.read(cx).snapshot.clone())) .collect() } + + fn process_updated_entries( + &self, + worktree: &Entity, + updated_entries: &[(Arc, ProjectEntryId, PathChange)], + cx: &mut App, + ) -> Task, Vec>> { + let mut repo_paths = self + .repositories + .values() + .map(|repo| (repo.read(cx).work_directory_abs_path.clone(), repo.clone())) + .collect::>(); + let mut entries: Vec<_> = updated_entries + .iter() + .map(|(path, _, _)| path.clone()) + .collect(); + entries.sort(); + let worktree = worktree.read(cx); + + let entries = entries + .into_iter() + .filter_map(|path| worktree.absolutize(&path).ok()) + .collect::>(); + + let executor = cx.background_executor().clone(); + cx.background_executor().spawn(async move { + repo_paths.sort_by(|lhs, rhs| lhs.0.cmp(&rhs.0)); + let mut paths_by_git_repo = HashMap::<_, Vec<_>>::default(); + let mut tasks = FuturesOrdered::new(); + for (repo_path, repo) in repo_paths.into_iter().rev() { + let entries = entries.clone(); + let task = executor.spawn(async move { + // Find all repository paths that belong to this repo + let mut ix = entries.partition_point(|path| path < &*repo_path); + if ix == entries.len() { + return None; + }; + + let mut paths = vec![]; + // All paths prefixed by a given repo will constitute a continuous range. + while let Some(path) = entries.get(ix) + && let Some(repo_path) = + RepositorySnapshot::abs_path_to_repo_path_inner(&repo_path, &path) + { + paths.push((repo_path, ix)); + ix += 1; + } + Some((repo, paths)) + }); + tasks.push_back(task); + } + + // Now, let's filter out the "duplicate" entries that were processed by multiple distinct repos. + let mut path_was_used = vec![false; entries.len()]; + let tasks = tasks.collect::>().await; + // Process tasks from the back: iterating backwards allows us to see more-specific paths first. + // We always want to assign a path to it's innermost repository. + for t in tasks { + let Some((repo, paths)) = t else { + continue; + }; + let entry = paths_by_git_repo.entry(repo).or_default(); + for (repo_path, ix) in paths { + if path_was_used[ix] { + continue; + } + path_was_used[ix] = true; + entry.push(repo_path); + } + } + + paths_by_git_repo + }) + } } impl BufferGitState { @@ -2660,8 +2734,16 @@ impl RepositorySnapshot { } pub fn abs_path_to_repo_path(&self, abs_path: &Path) -> Option { + Self::abs_path_to_repo_path_inner(&self.work_directory_abs_path, abs_path) + } + + #[inline] + fn abs_path_to_repo_path_inner( + work_directory_abs_path: &Path, + abs_path: &Path, + ) -> Option { abs_path - .strip_prefix(&self.work_directory_abs_path) + .strip_prefix(&work_directory_abs_path) .map(RepoPath::from) .ok() } diff --git a/crates/project/src/git_store/git_traversal.rs b/crates/project/src/git_store/git_traversal.rs index cd173d5714..777042cb02 100644 --- a/crates/project/src/git_store/git_traversal.rs +++ b/crates/project/src/git_store/git_traversal.rs @@ -1,6 +1,6 @@ use collections::HashMap; -use git::status::GitSummary; -use std::{ops::Deref, path::Path}; +use git::{repository::RepoPath, status::GitSummary}; +use std::{collections::BTreeMap, ops::Deref, path::Path}; use sum_tree::Cursor; use text::Bias; use worktree::{Entry, PathProgress, PathTarget, Traversal}; @@ -11,7 +11,7 @@ use super::{RepositoryId, RepositorySnapshot, StatusEntry}; pub struct GitTraversal<'a> { traversal: Traversal<'a>, current_entry_summary: Option, - repo_snapshots: &'a HashMap, + repo_root_to_snapshot: BTreeMap<&'a Path, &'a RepositorySnapshot>, repo_location: Option<(RepositoryId, Cursor<'a, StatusEntry, PathProgress<'a>>)>, } @@ -20,16 +20,46 @@ impl<'a> GitTraversal<'a> { repo_snapshots: &'a HashMap, traversal: Traversal<'a>, ) -> GitTraversal<'a> { + let repo_root_to_snapshot = repo_snapshots + .values() + .map(|snapshot| (&*snapshot.work_directory_abs_path, snapshot)) + .collect(); let mut this = GitTraversal { traversal, - repo_snapshots, current_entry_summary: None, repo_location: None, + repo_root_to_snapshot, }; this.synchronize_statuses(true); this } + fn repo_root_for_path(&self, path: &Path) -> Option<(&'a RepositorySnapshot, RepoPath)> { + // We might need to perform a range search multiple times, as there may be a nested repository inbetween + // the target and our path. E.g: + // /our_root_repo/ + // .git/ + // other_repo/ + // .git/ + // our_query.txt + let mut query = path.ancestors(); + while let Some(query) = query.next() { + let (_, snapshot) = self + .repo_root_to_snapshot + .range(Path::new("")..=query) + .last()?; + + let stripped = snapshot + .abs_path_to_repo_path(path) + .map(|repo_path| (*snapshot, repo_path)); + if stripped.is_some() { + return stripped; + } + } + + None + } + fn synchronize_statuses(&mut self, reset: bool) { self.current_entry_summary = None; @@ -42,15 +72,7 @@ impl<'a> GitTraversal<'a> { return; }; - let Some((repo, repo_path)) = self - .repo_snapshots - .values() - .filter_map(|repo_snapshot| { - let repo_path = repo_snapshot.abs_path_to_repo_path(&abs_path)?; - Some((repo_snapshot, repo_path)) - }) - .max_by_key(|(repo, _)| repo.work_directory_abs_path.clone()) - else { + let Some((repo, repo_path)) = self.repo_root_for_path(&abs_path) else { self.repo_location = None; return; }; From 57b463fd0df7785d1695ae126e86c88542969be3 Mon Sep 17 00:00:00 2001 From: Piotr Osiewicz <24362066+osiewicz@users.noreply.github.com> Date: Fri, 25 Jul 2025 14:23:52 +0200 Subject: [PATCH 049/893] typescript: Fix handling of jest/vitest tests with regex characters in name (#35090) Closes #35065 Release Notes: - JavaScript/TypeScript tasks: Fixed handling of Vitest/Jest tests with regex-specific characters in their name. --- crates/languages/src/typescript.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/languages/src/typescript.rs b/crates/languages/src/typescript.rs index 34b9c3224e..fb51544841 100644 --- a/crates/languages/src/typescript.rs +++ b/crates/languages/src/typescript.rs @@ -512,7 +512,7 @@ fn eslint_server_binary_arguments(server_path: &Path) -> Vec { fn replace_test_name_parameters(test_name: &str) -> String { let pattern = regex::Regex::new(r"(%|\$)[0-9a-zA-Z]+").unwrap(); - pattern.replace_all(test_name, "(.+?)").to_string() + regex::escape(&pattern.replace_all(test_name, "(.+?)")) } pub struct TypeScriptLspAdapter { From 9071341a1da9b0c9e3a88616e58646a4928c5414 Mon Sep 17 00:00:00 2001 From: Julia Ryan Date: Fri, 25 Jul 2025 07:40:26 -0500 Subject: [PATCH 050/893] Add TestCrash action (#35088) This triggers a crash that avoids our panic-handler, which is useful for testing that our crash reporting works even when you don't get a panic. Release Notes: - N/A --- crates/zed/src/zed.rs | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/crates/zed/src/zed.rs b/crates/zed/src/zed.rs index 57534c8cd5..0a90f89fa4 100644 --- a/crates/zed/src/zed.rs +++ b/crates/zed/src/zed.rs @@ -111,6 +111,8 @@ actions!( Zoom, /// Triggers a test panic for debugging. TestPanic, + /// Triggers a hard crash for debugging. + TestCrash, ] ); @@ -126,6 +128,14 @@ pub fn init(cx: &mut App) { cx.on_action(|_: &RestoreBanner, cx| title_bar::restore_banner(cx)); if ReleaseChannel::global(cx) == ReleaseChannel::Dev || cx.has_flag::() { cx.on_action(|_: &TestPanic, _| panic!("Ran the TestPanic action")); + cx.on_action(|_: &TestCrash, _| { + unsafe extern "C" { + fn puts(s: *const i8); + } + unsafe { + puts(0xabad1d3a as *const i8); + } + }); } cx.on_action(|_: &OpenLog, cx| { with_active_or_new_workspace(cx, |workspace, window, cx| { From a2408f353ba27b42abdfd3c1d13d9344566779d7 Mon Sep 17 00:00:00 2001 From: Julia Ryan Date: Fri, 25 Jul 2025 08:12:55 -0500 Subject: [PATCH 051/893] Don't separately rebuild crates for the build platform (#35084) macos: - `cargo build`: 1838 -> 1400 - `cargo build -r`1891 -> 1400 linux: - `cargo build`: 1893 -> 1455 - `cargo build -r`: 1893 -> 1455 windows: - `cargo build`: 1830 -> 1392 - `cargo build -r`: 1880 -> 1392 We definitely want this change for debug builds, for release builds it's _possible_ that it pessimizes the critical path, but we'll see if it impacts CI times before merging. Release Notes: - N/A --------- Co-authored-by: Rahul Butani --- Cargo.toml | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/Cargo.toml b/Cargo.toml index 9062950127..ea01003f36 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -720,6 +720,11 @@ workspace-hack = { path = "tooling/workspace-hack" } split-debuginfo = "unpacked" codegen-units = 16 +# mirror configuration for crates compiled for the build platform +# (without this cargo will compile ~400 crates twice) +[profile.dev.build-override] +codegen-units = 16 + [profile.dev.package] taffy = { opt-level = 3 } cranelift-codegen = { opt-level = 3 } From f21ba9e2c6789fadd3a59f88e0eb1ff4e1f919db Mon Sep 17 00:00:00 2001 From: Umesh Yadav <23421535+imumesh18@users.noreply.github.com> Date: Fri, 25 Jul 2025 19:06:43 +0530 Subject: [PATCH 052/893] lmstudio: Propagate actual error message from server (#34538) Discovered in this issue: #34513 Previously, we were propagating deserialization errors to users when using LMStudio, instead of the actual error message sent from the LMStudio server. This change will help users understand why their request failed while streaming responses. Release Notes: - lmsudio: Display specific backend error messaging on failure rather than generic ones --------- Signed-off-by: Umesh Yadav Co-authored-by: Peter Tripp --- crates/lmstudio/src/lmstudio.rs | 26 ++++++++++++++------------ 1 file changed, 14 insertions(+), 12 deletions(-) diff --git a/crates/lmstudio/src/lmstudio.rs b/crates/lmstudio/src/lmstudio.rs index a5477994ff..43c78115cd 100644 --- a/crates/lmstudio/src/lmstudio.rs +++ b/crates/lmstudio/src/lmstudio.rs @@ -1,4 +1,4 @@ -use anyhow::{Context as _, Result}; +use anyhow::{Context as _, Result, anyhow}; use futures::{AsyncBufReadExt, AsyncReadExt, StreamExt, io::BufReader, stream::BoxStream}; use http_client::{AsyncBody, HttpClient, Method, Request as HttpRequest, http}; use serde::{Deserialize, Serialize}; @@ -275,11 +275,16 @@ impl Capabilities { } } +#[derive(Serialize, Deserialize, Debug)] +pub struct LmStudioError { + pub message: String, +} + #[derive(Serialize, Deserialize, Debug)] #[serde(untagged)] pub enum ResponseStreamResult { Ok(ResponseStreamEvent), - Err { error: String }, + Err { error: LmStudioError }, } #[derive(Serialize, Deserialize, Debug)] @@ -392,7 +397,6 @@ pub async fn stream_chat_completion( let mut response = client.send(request).await?; if response.status().is_success() { let reader = BufReader::new(response.into_body()); - Ok(reader .lines() .filter_map(|line| async move { @@ -402,18 +406,16 @@ pub async fn stream_chat_completion( if line == "[DONE]" { None } else { - let result = serde_json::from_str(&line) - .context("Unable to parse chat completions response"); - if let Err(ref e) = result { - eprintln!("Error parsing line: {e}\nLine content: '{line}'"); + match serde_json::from_str(line) { + Ok(ResponseStreamResult::Ok(response)) => Some(Ok(response)), + Ok(ResponseStreamResult::Err { error, .. }) => { + Some(Err(anyhow!(error.message))) + } + Err(error) => Some(Err(anyhow!(error))), } - Some(result) } } - Err(e) => { - eprintln!("Error reading line: {e}"); - Some(Err(e.into())) - } + Err(error) => Some(Err(anyhow!(error))), } }) .boxed()) From 5de544eb4bf7841889da94c43b5f00d12398b2ef Mon Sep 17 00:00:00 2001 From: etimvr <80552426+etimvr@users.noreply.github.com> Date: Fri, 25 Jul 2025 20:58:05 +0700 Subject: [PATCH 053/893] Fix unnecessary Ollama model loading (#35032) Closes https://github.com/zed-industries/zed/issues/35031 Similar solution as in https://github.com/zed-industries/zed/pull/30589 Release Notes: - Fix unnecessary ollama model loading --- crates/language_models/src/provider/ollama.rs | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/crates/language_models/src/provider/ollama.rs b/crates/language_models/src/provider/ollama.rs index dc81e8be18..c20ea0ee1e 100644 --- a/crates/language_models/src/provider/ollama.rs +++ b/crates/language_models/src/provider/ollama.rs @@ -192,12 +192,16 @@ impl LanguageModelProvider for OllamaLanguageModelProvider { IconName::AiOllama } - fn default_model(&self, cx: &App) -> Option> { - self.provided_models(cx).into_iter().next() + fn default_model(&self, _: &App) -> Option> { + // We shouldn't try to select default model, because it might lead to a load call for an unloaded model. + // In a constrained environment where user might not have enough resources it'll be a bad UX to select something + // to load by default. + None } - fn default_fast_model(&self, cx: &App) -> Option> { - self.default_model(cx) + fn default_fast_model(&self, _: &App) -> Option> { + // See explanation for default_model. + None } fn provided_models(&self, cx: &App) -> Vec> { From 0e9d955e9bf25383f637bc7d4e3a385f43d30e09 Mon Sep 17 00:00:00 2001 From: Justin Su Date: Fri, 25 Jul 2025 10:53:57 -0400 Subject: [PATCH 054/893] Hide Copilot commands when AI functionality is disabled (#35055) Follow-up of https://github.com/zed-industries/zed/pull/34896 Related to https://github.com/zed-industries/zed/issues/31346 cc @rtfeldman Release Notes: - Hide copilot commands when AI functionality is disabled --- crates/agent_ui/src/agent_ui.rs | 3 +++ 1 file changed, 3 insertions(+) diff --git a/crates/agent_ui/src/agent_ui.rs b/crates/agent_ui/src/agent_ui.rs index cac0f1adac..6ae78585de 100644 --- a/crates/agent_ui/src/agent_ui.rs +++ b/crates/agent_ui/src/agent_ui.rs @@ -262,7 +262,9 @@ fn update_command_palette_filter(cx: &mut App) { if disable_ai { filter.hide_namespace("agent"); filter.hide_namespace("assistant"); + filter.hide_namespace("copilot"); filter.hide_namespace("zed_predict_onboarding"); + filter.hide_namespace("edit_prediction"); use editor::actions::{ @@ -282,6 +284,7 @@ fn update_command_palette_filter(cx: &mut App) { } else { filter.show_namespace("agent"); filter.show_namespace("assistant"); + filter.show_namespace("copilot"); filter.show_namespace("zed_predict_onboarding"); filter.show_namespace("edit_prediction"); From 985350f9e8fcaea66750c8b4a99d07a0ef0f39cf Mon Sep 17 00:00:00 2001 From: Piotr Osiewicz <24362066+osiewicz@users.noreply.github.com> Date: Fri, 25 Jul 2025 17:39:50 +0200 Subject: [PATCH 055/893] terminal: Support ~ in cwd field of task definitions (#35097) Closes #35022 Release Notes: - Fixed `~` not being expanded correctly in `cwd` field of task definitions. --- crates/project/src/terminals.rs | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) diff --git a/crates/project/src/terminals.rs b/crates/project/src/terminals.rs index 8cfbdff311..973d4e8811 100644 --- a/crates/project/src/terminals.rs +++ b/crates/project/src/terminals.rs @@ -213,17 +213,24 @@ impl Project { cx: &mut Context, ) -> Result> { let this = &mut *self; + let ssh_details = this.ssh_details(cx); let path: Option> = match &kind { TerminalKind::Shell(path) => path.as_ref().map(|path| Arc::from(path.as_ref())), TerminalKind::Task(spawn_task) => { if let Some(cwd) = &spawn_task.cwd { - Some(Arc::from(cwd.as_ref())) + if ssh_details.is_some() { + Some(Arc::from(cwd.as_ref())) + } else { + let cwd = cwd.to_string_lossy(); + let tilde_substituted = shellexpand::tilde(&cwd); + Some(Arc::from(Path::new(tilde_substituted.as_ref()))) + } } else { this.active_project_directory(cx) } } }; - let ssh_details = this.ssh_details(cx); + let is_ssh_terminal = ssh_details.is_some(); let mut settings_location = None; From abb3ed1ed1bee71a8fd0c5e805f4020a9aa20ab6 Mon Sep 17 00:00:00 2001 From: Piotr Osiewicz <24362066+osiewicz@users.noreply.github.com> Date: Fri, 25 Jul 2025 17:48:09 +0200 Subject: [PATCH 056/893] git: Fix commit modal contents being searchable (#35099) Fixes #35093 Release Notes: - Fixed Git commit editor being searchable. --- crates/git_ui/src/git_panel.rs | 3 +++ 1 file changed, 3 insertions(+) diff --git a/crates/git_ui/src/git_panel.rs b/crates/git_ui/src/git_panel.rs index 061833a6c7..a8d1da7daf 100644 --- a/crates/git_ui/src/git_panel.rs +++ b/crates/git_ui/src/git_panel.rs @@ -380,6 +380,9 @@ pub(crate) fn commit_message_editor( window: &mut Window, cx: &mut Context, ) -> Editor { + project.update(cx, |this, cx| { + this.mark_buffer_as_non_searchable(commit_message_buffer.read(cx).remote_id(), cx); + }); let buffer = cx.new(|cx| MultiBuffer::singleton(commit_message_buffer, cx)); let max_lines = if in_panel { MAX_PANEL_EDITOR_LINES } else { 18 }; let mut commit_editor = Editor::new( From 993d5753d5997ca0766626dc225771aac76031f7 Mon Sep 17 00:00:00 2001 From: Haojian Wu Date: Fri, 25 Jul 2025 18:14:44 +0200 Subject: [PATCH 057/893] docs: Add a missing "," in the C/C++ debugger configuration (#35098) Release Notes: - N/A --- docs/src/languages/c.md | 2 +- docs/src/languages/cpp.md | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/src/languages/c.md b/docs/src/languages/c.md index 14a11c0d66..8db1bb6712 100644 --- a/docs/src/languages/c.md +++ b/docs/src/languages/c.md @@ -77,7 +77,7 @@ You can use CodeLLDB or GDB to debug native binaries. (Make sure that your build "command": "make", "args": ["-j8"], "cwd": "$ZED_WORKTREE_ROOT" - } + }, "program": "$ZED_WORKTREE_ROOT/build/prog", "request": "launch", "adapter": "CodeLLDB" diff --git a/docs/src/languages/cpp.md b/docs/src/languages/cpp.md index 1273bce2ac..e84bb6ea50 100644 --- a/docs/src/languages/cpp.md +++ b/docs/src/languages/cpp.md @@ -127,7 +127,7 @@ You can use CodeLLDB or GDB to debug native binaries. (Make sure that your build "command": "make", "args": ["-j8"], "cwd": "$ZED_WORKTREE_ROOT" - } + }, "program": "$ZED_WORKTREE_ROOT/build/prog", "request": "launch", "adapter": "CodeLLDB" From 2f812c339c1e1f01a3c04d38ca5190520df73c85 Mon Sep 17 00:00:00 2001 From: Umesh Yadav <23421535+imumesh18@users.noreply.github.com> Date: Fri, 25 Jul 2025 22:25:38 +0530 Subject: [PATCH 058/893] agent_ui: Fix delay when loading keybindings in the Agent panel settings (#34954) Fixes a annoying lag in agent settings panel where the keybindings would show up after a lag. Close to 1-2 secs. It was a simple fix previously we were not passing the focus handler to context menu which made the keybindings lookup slower compared to other parts like git panel and title bar profile dropdown. | Before | After | |--------|--------| | | | Release Notes: - Fix delay when loading keybindings in the Agent panel settings --- crates/agent_ui/src/agent_panel.rs | 116 +++++++++++++++-------------- 1 file changed, 60 insertions(+), 56 deletions(-) diff --git a/crates/agent_ui/src/agent_panel.rs b/crates/agent_ui/src/agent_panel.rs index 4b3db4bc1d..43c1167af8 100644 --- a/crates/agent_ui/src/agent_panel.rs +++ b/crates/agent_ui/src/agent_panel.rs @@ -2016,65 +2016,69 @@ impl AgentPanel { ) .anchor(Corner::TopRight) .with_handle(self.agent_panel_menu_handle.clone()) - .menu(move |window, cx| { - Some(ContextMenu::build(window, cx, |mut menu, _window, _| { - if let Some(usage) = usage { + .menu({ + let focus_handle = focus_handle.clone(); + move |window, cx| { + Some(ContextMenu::build(window, cx, |mut menu, _window, _| { + menu = menu.context(focus_handle.clone()); + if let Some(usage) = usage { + menu = menu + .header_with_link("Prompt Usage", "Manage", account_url.clone()) + .custom_entry( + move |_window, cx| { + let used_percentage = match usage.limit { + UsageLimit::Limited(limit) => { + Some((usage.amount as f32 / limit as f32) * 100.) + } + UsageLimit::Unlimited => None, + }; + + h_flex() + .flex_1() + .gap_1p5() + .children(used_percentage.map(|percent| { + ProgressBar::new("usage", percent, 100., cx) + })) + .child( + Label::new(match usage.limit { + UsageLimit::Limited(limit) => { + format!("{} / {limit}", usage.amount) + } + UsageLimit::Unlimited => { + format!("{} / ∞", usage.amount) + } + }) + .size(LabelSize::Small) + .color(Color::Muted), + ) + .into_any_element() + }, + move |_, cx| cx.open_url(&zed_urls::account_url(cx)), + ) + .separator() + } + menu = menu - .header_with_link("Prompt Usage", "Manage", account_url.clone()) - .custom_entry( - move |_window, cx| { - let used_percentage = match usage.limit { - UsageLimit::Limited(limit) => { - Some((usage.amount as f32 / limit as f32) * 100.) - } - UsageLimit::Unlimited => None, - }; - - h_flex() - .flex_1() - .gap_1p5() - .children(used_percentage.map(|percent| { - ProgressBar::new("usage", percent, 100., cx) - })) - .child( - Label::new(match usage.limit { - UsageLimit::Limited(limit) => { - format!("{} / {limit}", usage.amount) - } - UsageLimit::Unlimited => { - format!("{} / ∞", usage.amount) - } - }) - .size(LabelSize::Small) - .color(Color::Muted), - ) - .into_any_element() - }, - move |_, cx| cx.open_url(&zed_urls::account_url(cx)), + .header("MCP Servers") + .action( + "View Server Extensions", + Box::new(zed_actions::Extensions { + category_filter: Some( + zed_actions::ExtensionCategoryFilter::ContextServers, + ), + id: None, + }), ) - .separator() - } + .action("Add Custom Server…", Box::new(AddContextServer)) + .separator(); - menu = menu - .header("MCP Servers") - .action( - "View Server Extensions", - Box::new(zed_actions::Extensions { - category_filter: Some( - zed_actions::ExtensionCategoryFilter::ContextServers, - ), - id: None, - }), - ) - .action("Add Custom Server…", Box::new(AddContextServer)) - .separator(); - - menu = menu - .action("Rules…", Box::new(OpenRulesLibrary::default())) - .action("Settings", Box::new(OpenConfiguration)) - .action(zoom_in_label, Box::new(ToggleZoom)); - menu - })) + menu = menu + .action("Rules…", Box::new(OpenRulesLibrary::default())) + .action("Settings", Box::new(OpenConfiguration)) + .action(zoom_in_label, Box::new(ToggleZoom)); + menu + })) + } }); h_flex() From cd5095872748ef2d56fa03b54e40b6aaa5ff7906 Mon Sep 17 00:00:00 2001 From: Kainoa Kanter Date: Fri, 25 Jul 2025 10:17:16 -0700 Subject: [PATCH 059/893] Add icon for SurrealQL files (#34855) Release Notes: - Added icon for SurrealQL (`.surql`) files --------- Co-authored-by: Danilo Leal --- assets/icons/file_icons/surrealql.svg | 3 +++ crates/theme/src/icon_theme.rs | 2 ++ 2 files changed, 5 insertions(+) create mode 100644 assets/icons/file_icons/surrealql.svg diff --git a/assets/icons/file_icons/surrealql.svg b/assets/icons/file_icons/surrealql.svg new file mode 100644 index 0000000000..076f93e808 --- /dev/null +++ b/assets/icons/file_icons/surrealql.svg @@ -0,0 +1,3 @@ + + + diff --git a/crates/theme/src/icon_theme.rs b/crates/theme/src/icon_theme.rs index 09f5df06b0..baa928d722 100644 --- a/crates/theme/src/icon_theme.rs +++ b/crates/theme/src/icon_theme.rs @@ -216,6 +216,7 @@ const FILE_SUFFIXES_BY_ICON_KEY: &[(&str, &[&str])] = &[ "stylelintrc.yml", ], ), + ("surrealql", &["surql"]), ("svelte", &["svelte"]), ("swift", &["swift"]), ("tcl", &["tcl"]), @@ -340,6 +341,7 @@ const FILE_ICONS: &[(&str, &str)] = &[ ("solidity", "icons/file_icons/file.svg"), ("storage", "icons/file_icons/database.svg"), ("stylelint", "icons/file_icons/javascript.svg"), + ("surrealql", "icons/file_icons/surrealql.svg"), ("svelte", "icons/file_icons/html.svg"), ("swift", "icons/file_icons/swift.svg"), ("tcl", "icons/file_icons/tcl.svg"), From 4abe14f94a30c0fc9c4e0e3ef14cae7609f7b429 Mon Sep 17 00:00:00 2001 From: Anthony Eid <56899983+Anthony-Eid@users.noreply.github.com> Date: Fri, 25 Jul 2025 13:19:05 -0400 Subject: [PATCH 060/893] keymap ui: Resize columns on double click improvement (#35095) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This PR improves the behavior of resetting a column's size by double-clicking on its column handle. We now shrink/grow to the side that has more leftover/additional space. We also improved the below 1. dragging was a couple of pixels off to the left because we didn't take the column handle’s width into account. 2. Column dragging now has memory and will shift things to their exact position when reversing a drag before letting the drag handle go. 3. Improved our test infrastructure. 4. Double clicking on a column's header resizes the column Release Notes: - N/A --------- Co-authored-by: Ben Kunkle --- crates/settings_ui/Cargo.toml | 3 + crates/settings_ui/src/ui_components/table.rs | 637 +++++++++++++++--- 2 files changed, 546 insertions(+), 94 deletions(-) diff --git a/crates/settings_ui/Cargo.toml b/crates/settings_ui/Cargo.toml index 02327045fd..25f033469d 100644 --- a/crates/settings_ui/Cargo.toml +++ b/crates/settings_ui/Cargo.toml @@ -45,3 +45,6 @@ ui_input.workspace = true util.workspace = true workspace-hack.workspace = true workspace.workspace = true + +[dev-dependencies] +db = {"workspace"= true, "features" = ["test-support"]} diff --git a/crates/settings_ui/src/ui_components/table.rs b/crates/settings_ui/src/ui_components/table.rs index 69207f559b..65778c20eb 100644 --- a/crates/settings_ui/src/ui_components/table.rs +++ b/crates/settings_ui/src/ui_components/table.rs @@ -2,9 +2,9 @@ use std::{ops::Range, rc::Rc, time::Duration}; use editor::{EditorSettings, ShowScrollbar, scroll::ScrollbarAutoHide}; use gpui::{ - AbsoluteLength, AppContext, Axis, Context, DefiniteLength, DragMoveEvent, Entity, FocusHandle, - Length, ListHorizontalSizingBehavior, ListSizingBehavior, MouseButton, Point, Stateful, Task, - UniformListScrollHandle, WeakEntity, transparent_black, uniform_list, + AbsoluteLength, AppContext, Axis, Context, DefiniteLength, DragMoveEvent, Entity, EntityId, + FocusHandle, Length, ListHorizontalSizingBehavior, ListSizingBehavior, MouseButton, Point, + Stateful, Task, UniformListScrollHandle, WeakEntity, transparent_black, uniform_list, }; use itertools::intersperse_with; @@ -13,10 +13,12 @@ use ui::{ ActiveTheme as _, AnyElement, App, Button, ButtonCommon as _, ButtonStyle, Color, Component, ComponentScope, Div, ElementId, FixedWidth as _, FluentBuilder as _, Indicator, InteractiveElement, IntoElement, ParentElement, Pixels, RegisterComponent, RenderOnce, - Scrollbar, ScrollbarState, StatefulInteractiveElement, Styled, StyledExt as _, + Scrollbar, ScrollbarState, SharedString, StatefulInteractiveElement, Styled, StyledExt as _, StyledTypography, Window, div, example_group_with_title, h_flex, px, single_example, v_flex, }; +const RESIZE_COLUMN_WIDTH: f32 = 5.0; + #[derive(Debug)] struct DraggedColumn(usize); @@ -227,7 +229,7 @@ impl TableInteractionState { .id("column-resize-handle") .absolute() .left_neg_0p5() - .w(px(5.0)) + .w(px(RESIZE_COLUMN_WIDTH)) .h_full(); if resizable_columns @@ -478,6 +480,7 @@ impl ResizeBehavior { pub struct ColumnWidths { widths: [DefiniteLength; COLS], + visible_widths: [DefiniteLength; COLS], cached_bounds_width: Pixels, initialized: bool, } @@ -486,6 +489,7 @@ impl ColumnWidths { pub fn new(_: &mut App) -> Self { Self { widths: [DefiniteLength::default(); COLS], + visible_widths: [DefiniteLength::default(); COLS], cached_bounds_width: Default::default(), initialized: false, } @@ -512,46 +516,105 @@ impl ColumnWidths { let rem_size = window.rem_size(); let initial_sizes = initial_sizes.map(|length| Self::get_fraction(&length, bounds_width, rem_size)); - let mut widths = self + let widths = self .widths .map(|length| Self::get_fraction(&length, bounds_width, rem_size)); - let diff = initial_sizes[double_click_position] - widths[double_click_position]; + let updated_widths = Self::reset_to_initial_size( + double_click_position, + widths, + initial_sizes, + resize_behavior, + ); + self.widths = updated_widths.map(DefiniteLength::Fraction); + self.visible_widths = self.widths; + } - if diff > 0.0 { - let diff_remaining = self.propagate_resize_diff_right( - diff, - double_click_position, - &mut widths, - resize_behavior, - ); + fn reset_to_initial_size( + col_idx: usize, + mut widths: [f32; COLS], + initial_sizes: [f32; COLS], + resize_behavior: &[ResizeBehavior; COLS], + ) -> [f32; COLS] { + // RESET: + // Part 1: + // Figure out if we should shrink/grow the selected column + // Get diff which represents the change in column we want to make initial size delta curr_size = diff + // + // Part 2: We need to decide which side column we should move and where + // + // If we want to grow our column we should check the left/right columns diff to see what side + // has a greater delta than their initial size. Likewise, if we shrink our column we should check + // the left/right column diffs to see what side has the smallest delta. + // + // Part 3: resize + // + // col_idx represents the column handle to the right of an active column + // + // If growing and right has the greater delta { + // shift col_idx to the right + // } else if growing and left has the greater delta { + // shift col_idx - 1 to the left + // } else if shrinking and the right has the greater delta { + // shift + // } { + // + // } + // } + // + // if we need to shrink, then if the right + // - if diff_remaining > 0.0 && double_click_position > 0 { - self.propagate_resize_diff_left( - -diff_remaining, - double_click_position - 1, + // DRAGGING + // we get diff which represents the change in the _drag handle_ position + // -diff => dragging left -> + // grow the column to the right of the handle as much as we can shrink columns to the left of the handle + // +diff => dragging right -> growing handles column + // grow the column to the left of the handle as much as we can shrink columns to the right of the handle + // + + let diff = initial_sizes[col_idx] - widths[col_idx]; + + let left_diff = + initial_sizes[..col_idx].iter().sum::() - widths[..col_idx].iter().sum::(); + let right_diff = initial_sizes[col_idx + 1..].iter().sum::() + - widths[col_idx + 1..].iter().sum::(); + + let go_left_first = if diff < 0.0 { + left_diff > right_diff + } else { + left_diff < right_diff + }; + + if !go_left_first { + let diff_remaining = + Self::propagate_resize_diff(diff, col_idx, &mut widths, resize_behavior, 1); + + if diff_remaining != 0.0 && col_idx > 0 { + Self::propagate_resize_diff( + diff_remaining, + col_idx, &mut widths, resize_behavior, + -1, ); } - } else if double_click_position > 0 { - let diff_remaining = self.propagate_resize_diff_left( - diff, - double_click_position, - &mut widths, - resize_behavior, - ); + } else { + let diff_remaining = + Self::propagate_resize_diff(diff, col_idx, &mut widths, resize_behavior, -1); - if diff_remaining < 0.0 { - self.propagate_resize_diff_right( - -diff_remaining, - double_click_position, + if diff_remaining != 0.0 { + Self::propagate_resize_diff( + diff_remaining, + col_idx, &mut widths, resize_behavior, + 1, ); } } - self.widths = widths.map(DefiniteLength::Fraction); + + widths } fn on_drag_move( @@ -569,98 +632,102 @@ impl ColumnWidths { let bounds_width = bounds.right() - bounds.left(); let col_idx = drag_event.drag(cx).0; + let column_handle_width = Self::get_fraction( + &DefiniteLength::Absolute(AbsoluteLength::Pixels(px(RESIZE_COLUMN_WIDTH))), + bounds_width, + rem_size, + ); + let mut widths = self .widths .map(|length| Self::get_fraction(&length, bounds_width, rem_size)); for length in widths[0..=col_idx].iter() { - col_position += length; + col_position += length + column_handle_width; } let mut total_length_ratio = col_position; for length in widths[col_idx + 1..].iter() { total_length_ratio += length; } + total_length_ratio += (COLS - 1 - col_idx) as f32 * column_handle_width; let drag_fraction = (drag_position.x - bounds.left()) / bounds_width; let drag_fraction = drag_fraction * total_length_ratio; - let diff = drag_fraction - col_position; + let diff = drag_fraction - col_position - column_handle_width / 2.0; - let is_dragging_right = diff > 0.0; + Self::drag_column_handle(diff, col_idx, &mut widths, resize_behavior); - if is_dragging_right { - self.propagate_resize_diff_right(diff, col_idx, &mut widths, resize_behavior); - } else { - // Resize behavior should be improved in the future by also seeking to the right column when there's not enough space - self.propagate_resize_diff_left(diff, col_idx, &mut widths, resize_behavior); - } - self.widths = widths.map(DefiniteLength::Fraction); + self.visible_widths = widths.map(DefiniteLength::Fraction); } - fn propagate_resize_diff_right( - &self, + fn drag_column_handle( diff: f32, col_idx: usize, widths: &mut [f32; COLS], resize_behavior: &[ResizeBehavior; COLS], - ) -> f32 { - let mut diff_remaining = diff; - let mut curr_column = col_idx + 1; - - while diff_remaining > 0.0 && curr_column < COLS { - let Some(min_size) = resize_behavior[curr_column - 1].min_size() else { - curr_column += 1; - continue; - }; - - let mut curr_width = widths[curr_column] - diff_remaining; - - diff_remaining = 0.0; - if min_size > curr_width { - diff_remaining += min_size - curr_width; - curr_width = min_size; - } - widths[curr_column] = curr_width; - curr_column += 1; + ) { + // if diff > 0.0 then go right + if diff > 0.0 { + Self::propagate_resize_diff(diff, col_idx, widths, resize_behavior, 1); + } else { + Self::propagate_resize_diff(-diff, col_idx + 1, widths, resize_behavior, -1); } - - widths[col_idx] = widths[col_idx] + (diff - diff_remaining); - return diff_remaining; } - fn propagate_resize_diff_left( - &mut self, + fn propagate_resize_diff( diff: f32, - mut curr_column: usize, + col_idx: usize, widths: &mut [f32; COLS], resize_behavior: &[ResizeBehavior; COLS], + direction: i8, ) -> f32 { let mut diff_remaining = diff; - let col_idx = curr_column; - while diff_remaining < 0.0 { + if resize_behavior[col_idx].min_size().is_none() { + return diff; + } + + let step_right; + let step_left; + if direction < 0 { + step_right = 0; + step_left = 1; + } else { + step_right = 1; + step_left = 0; + } + if col_idx == 0 && direction < 0 { + return diff; + } + let mut curr_column = col_idx + step_right - step_left; + + while diff_remaining != 0.0 && curr_column < COLS { let Some(min_size) = resize_behavior[curr_column].min_size() else { if curr_column == 0 { break; } - curr_column -= 1; + curr_column -= step_left; + curr_column += step_right; continue; }; - let mut curr_width = widths[curr_column] + diff_remaining; - - diff_remaining = 0.0; - if curr_width < min_size { - diff_remaining = curr_width - min_size; - curr_width = min_size - } - + let curr_width = widths[curr_column] - diff_remaining; widths[curr_column] = curr_width; + + if min_size > curr_width { + diff_remaining = min_size - curr_width; + widths[curr_column] = min_size; + } else { + diff_remaining = 0.0; + break; + } if curr_column == 0 { break; } - curr_column -= 1; + curr_column -= step_left; + curr_column += step_right; } - widths[col_idx + 1] = widths[col_idx + 1] - (diff - diff_remaining); + widths[col_idx] = widths[col_idx] + (diff - diff_remaining); return diff_remaining; } @@ -686,7 +753,7 @@ impl TableWidths { fn lengths(&self, cx: &App) -> [Length; COLS] { self.current .as_ref() - .map(|entity| entity.read(cx).widths.map(Length::Definite)) + .map(|entity| entity.read(cx).visible_widths.map(Length::Definite)) .unwrap_or(self.initial.map(Length::Definite)) } } @@ -799,6 +866,7 @@ impl Table { if !widths.initialized { widths.initialized = true; widths.widths = table_widths.initial; + widths.visible_widths = widths.widths; } }) } @@ -888,11 +956,24 @@ pub fn render_row( pub fn render_header( headers: [impl IntoElement; COLS], table_context: TableRenderContext, + columns_widths: Option<( + WeakEntity>, + [ResizeBehavior; COLS], + [DefiniteLength; COLS], + )>, + entity_id: Option, cx: &mut App, ) -> impl IntoElement { let column_widths = table_context .column_widths .map_or([None; COLS], |widths| widths.map(Some)); + + let element_id = entity_id + .map(|entity| entity.to_string()) + .unwrap_or_default(); + + let shared_element_id: SharedString = format!("table-{}", element_id).into(); + div() .flex() .flex_row() @@ -902,12 +983,39 @@ pub fn render_header( .p_2() .border_b_1() .border_color(cx.theme().colors().border) - .children( - headers - .into_iter() - .zip(column_widths) - .map(|(h, width)| base_cell_style_text(width, cx).child(h)), - ) + .children(headers.into_iter().enumerate().zip(column_widths).map( + |((header_idx, h), width)| { + base_cell_style_text(width, cx) + .child(h) + .id(ElementId::NamedInteger( + shared_element_id.clone(), + header_idx as u64, + )) + .when_some( + columns_widths.as_ref().cloned(), + |this, (column_widths, resizables, initial_sizes)| { + if resizables[header_idx].is_resizable() { + this.on_click(move |event, window, cx| { + if event.down.click_count > 1 { + column_widths + .update(cx, |column, _| { + column.on_double_click( + header_idx, + &initial_sizes, + &resizables, + window, + ); + }) + .ok(); + } + }) + } else { + this + } + }, + ) + }, + )) } #[derive(Clone)] @@ -939,6 +1047,12 @@ impl RenderOnce for Table { .and_then(|widths| Some((widths.current.as_ref()?, widths.resizable))) .map(|(curr, resize_behavior)| (curr.downgrade(), resize_behavior)); + let current_widths_with_initial_sizes = self + .col_widths + .as_ref() + .and_then(|widths| Some((widths.current.as_ref()?, widths.resizable, widths.initial))) + .map(|(curr, resize_behavior, initial)| (curr.downgrade(), resize_behavior, initial)); + let scroll_track_size = px(16.); let h_scroll_offset = if interaction_state .as_ref() @@ -958,7 +1072,13 @@ impl RenderOnce for Table { .h_full() .v_flex() .when_some(self.headers.take(), |this, headers| { - this.child(render_header(headers, table_context.clone(), cx)) + this.child(render_header( + headers, + table_context.clone(), + current_widths_with_initial_sizes, + interaction_state.as_ref().map(Entity::entity_id), + cx, + )) }) .when_some(current_widths, { |this, (widths, resize_behavior)| { @@ -972,19 +1092,28 @@ impl RenderOnce for Table { .ok(); } }) - .on_children_prepainted(move |bounds, _, cx| { + .on_children_prepainted({ + let widths = widths.clone(); + move |bounds, _, cx| { + widths + .update(cx, |widths, _| { + // This works because all children x axis bounds are the same + widths.cached_bounds_width = + bounds[0].right() - bounds[0].left(); + }) + .ok(); + } + }) + .on_drop::(move |_, _, cx| { widths .update(cx, |widths, _| { - // This works because all children x axis bounds are the same - widths.cached_bounds_width = bounds[0].right() - bounds[0].left(); + widths.widths = widths.visible_widths; }) .ok(); + // Finish the resize operation }) } }) - .on_drop::(|_, _, _| { - // Finish the resize operation - }) .child( div() .flex_grow() @@ -1313,3 +1442,323 @@ impl Component for Table<3> { ) } } + +#[cfg(test)] +mod test { + use super::*; + + fn is_almost_eq(a: &[f32], b: &[f32]) -> bool { + a.len() == b.len() && a.iter().zip(b).all(|(x, y)| (x - y).abs() < 1e-6) + } + + fn cols_to_str(cols: &[f32; COLS], total_size: f32) -> String { + cols.map(|f| "*".repeat(f32::round(f * total_size) as usize)) + .join("|") + } + + fn parse_resize_behavior( + input: &str, + total_size: f32, + ) -> [ResizeBehavior; COLS] { + let mut resize_behavior = [ResizeBehavior::None; COLS]; + let mut max_index = 0; + for (index, col) in input.split('|').enumerate() { + if col.starts_with('X') || col.is_empty() { + resize_behavior[index] = ResizeBehavior::None; + } else if col.starts_with('*') { + resize_behavior[index] = ResizeBehavior::MinSize(col.len() as f32 / total_size); + } else { + panic!("invalid test input: unrecognized resize behavior: {}", col); + } + max_index = index; + } + + if max_index + 1 != COLS { + panic!("invalid test input: too many columns"); + } + resize_behavior + } + + mod reset_column_size { + use super::*; + + fn parse(input: &str) -> ([f32; COLS], f32, Option) { + let mut widths = [f32::NAN; COLS]; + let mut column_index = None; + for (index, col) in input.split('|').enumerate() { + widths[index] = col.len() as f32; + if col.starts_with('X') { + column_index = Some(index); + } + } + + for w in widths { + assert!(w.is_finite(), "incorrect number of columns"); + } + let total = widths.iter().sum::(); + for width in &mut widths { + *width /= total; + } + (widths, total, column_index) + } + + #[track_caller] + fn check_reset_size( + initial_sizes: &str, + widths: &str, + expected: &str, + resize_behavior: &str, + ) { + let (initial_sizes, total_1, None) = parse::(initial_sizes) else { + panic!("invalid test input: initial sizes should not be marked"); + }; + let (widths, total_2, Some(column_index)) = parse::(widths) else { + panic!("invalid test input: widths should be marked"); + }; + assert_eq!( + total_1, total_2, + "invalid test input: total width not the same {total_1}, {total_2}" + ); + let (expected, total_3, None) = parse::(expected) else { + panic!("invalid test input: expected should not be marked: {expected:?}"); + }; + assert_eq!( + total_2, total_3, + "invalid test input: total width not the same" + ); + let resize_behavior = parse_resize_behavior::(resize_behavior, total_1); + let result = ColumnWidths::reset_to_initial_size( + column_index, + widths, + initial_sizes, + &resize_behavior, + ); + let is_eq = is_almost_eq(&result, &expected); + if !is_eq { + let result_str = cols_to_str(&result, total_1); + let expected_str = cols_to_str(&expected, total_1); + panic!( + "resize failed\ncomputed: {result_str}\nexpected: {expected_str}\n\ncomputed values: {result:?}\nexpected values: {expected:?}\n:minimum widths: {resize_behavior:?}" + ); + } + } + + macro_rules! check_reset_size { + (columns: $cols:expr, starting: $initial:expr, snapshot: $current:expr, expected: $expected:expr, resizing: $resizing:expr $(,)?) => { + check_reset_size::<$cols>($initial, $current, $expected, $resizing); + }; + ($name:ident, columns: $cols:expr, starting: $initial:expr, snapshot: $current:expr, expected: $expected:expr, minimums: $resizing:expr $(,)?) => { + #[test] + fn $name() { + check_reset_size::<$cols>($initial, $current, $expected, $resizing); + } + }; + } + + check_reset_size!( + basic_right, + columns: 5, + starting: "**|**|**|**|**", + snapshot: "**|**|X|***|**", + expected: "**|**|**|**|**", + minimums: "X|*|*|*|*", + ); + + check_reset_size!( + basic_left, + columns: 5, + starting: "**|**|**|**|**", + snapshot: "**|**|***|X|**", + expected: "**|**|**|**|**", + minimums: "X|*|*|*|**", + ); + + check_reset_size!( + squashed_left_reset_col2, + columns: 6, + starting: "*|***|**|**|****|*", + snapshot: "*|*|X|*|*|********", + expected: "*|*|**|*|*|*******", + minimums: "X|*|*|*|*|*", + ); + + check_reset_size!( + grow_cascading_right, + columns: 6, + starting: "*|***|****|**|***|*", + snapshot: "*|***|X|**|**|*****", + expected: "*|***|****|*|*|****", + minimums: "X|*|*|*|*|*", + ); + + check_reset_size!( + squashed_right_reset_col4, + columns: 6, + starting: "*|***|**|**|****|*", + snapshot: "*|********|*|*|X|*", + expected: "*|*****|*|*|****|*", + minimums: "X|*|*|*|*|*", + ); + + check_reset_size!( + reset_col6_right, + columns: 6, + starting: "*|***|**|***|***|**", + snapshot: "*|***|**|***|**|XXX", + expected: "*|***|**|***|***|**", + minimums: "X|*|*|*|*|*", + ); + + check_reset_size!( + reset_col6_left, + columns: 6, + starting: "*|***|**|***|***|**", + snapshot: "*|***|**|***|****|X", + expected: "*|***|**|***|***|**", + minimums: "X|*|*|*|*|*", + ); + + check_reset_size!( + last_column_grow_cascading, + columns: 6, + starting: "*|***|**|**|**|***", + snapshot: "*|*******|*|**|*|X", + expected: "*|******|*|*|*|***", + minimums: "X|*|*|*|*|*", + ); + + check_reset_size!( + goes_left_when_left_has_extreme_diff, + columns: 6, + starting: "*|***|****|**|**|***", + snapshot: "*|********|X|*|**|**", + expected: "*|*****|****|*|**|**", + minimums: "X|*|*|*|*|*", + ); + + check_reset_size!( + basic_shrink_right, + columns: 6, + starting: "**|**|**|**|**|**", + snapshot: "**|**|XXX|*|**|**", + expected: "**|**|**|**|**|**", + minimums: "X|*|*|*|*|*", + ); + + check_reset_size!( + shrink_should_go_left, + columns: 6, + starting: "*|***|**|*|*|*", + snapshot: "*|*|XXX|**|*|*", + expected: "*|**|**|**|*|*", + minimums: "X|*|*|*|*|*", + ); + + check_reset_size!( + shrink_should_go_right, + columns: 6, + starting: "*|***|**|**|**|*", + snapshot: "*|****|XXX|*|*|*", + expected: "*|****|**|**|*|*", + minimums: "X|*|*|*|*|*", + ); + } + + mod drag_handle { + use super::*; + + fn parse(input: &str) -> ([f32; COLS], f32, Option) { + let mut widths = [f32::NAN; COLS]; + let column_index = input.replace("*", "").find("I"); + for (index, col) in input.replace("I", "|").split('|').enumerate() { + widths[index] = col.len() as f32; + } + + for w in widths { + assert!(w.is_finite(), "incorrect number of columns"); + } + let total = widths.iter().sum::(); + for width in &mut widths { + *width /= total; + } + (widths, total, column_index) + } + + #[track_caller] + fn check( + distance: i32, + widths: &str, + expected: &str, + resize_behavior: &str, + ) { + let (mut widths, total_1, Some(column_index)) = parse::(widths) else { + panic!("invalid test input: widths should be marked"); + }; + let (expected, total_2, None) = parse::(expected) else { + panic!("invalid test input: expected should not be marked: {expected:?}"); + }; + assert_eq!( + total_1, total_2, + "invalid test input: total width not the same" + ); + let resize_behavior = parse_resize_behavior::(resize_behavior, total_1); + + let distance = distance as f32 / total_1; + + let result = ColumnWidths::drag_column_handle( + distance, + column_index, + &mut widths, + &resize_behavior, + ); + + let is_eq = is_almost_eq(&widths, &expected); + if !is_eq { + let result_str = cols_to_str(&widths, total_1); + let expected_str = cols_to_str(&expected, total_1); + panic!( + "resize failed\ncomputed: {result_str}\nexpected: {expected_str}\n\ncomputed values: {result:?}\nexpected values: {expected:?}\n:minimum widths: {resize_behavior:?}" + ); + } + } + + macro_rules! check { + (columns: $cols:expr, distance: $dist:expr, snapshot: $current:expr, expected: $expected:expr, resizing: $resizing:expr $(,)?) => { + check!($cols, $dist, $snapshot, $expected, $resizing); + }; + ($name:ident, columns: $cols:expr, distance: $dist:expr, snapshot: $current:expr, expected: $expected:expr, minimums: $resizing:expr $(,)?) => { + #[test] + fn $name() { + check::<$cols>($dist, $current, $expected, $resizing); + } + }; + } + + check!( + basic_right_drag, + columns: 3, + distance: 1, + snapshot: "**|**I**", + expected: "**|***|*", + minimums: "X|*|*", + ); + + check!( + drag_left_against_mins, + columns: 5, + distance: -1, + snapshot: "*|*|*|*I*******", + expected: "*|*|*|*|*******", + minimums: "X|*|*|*|*", + ); + + check!( + drag_left, + columns: 5, + distance: -2, + snapshot: "*|*|*|*****I***", + expected: "*|*|*|***|*****", + minimums: "X|*|*|*|*", + ); + } +} From ff67f18e0d334b4d5521f17412e0bd704452edaa Mon Sep 17 00:00:00 2001 From: Cole Miller Date: Fri, 25 Jul 2025 10:36:58 -0700 Subject: [PATCH 061/893] Bump livekit dep to try to fix flaky builds (#35103) Let's see if https://github.com/zed-industries/livekit-rust-sdks/pull/6 helps. Release Notes: - N/A --------- Signed-off-by: Cole Miller --- Cargo.lock | 22 +++++++++++++++------- crates/livekit_client/Cargo.toml | 4 ++-- 2 files changed, 17 insertions(+), 9 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 2c65131db0..82790da17f 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -7688,6 +7688,12 @@ version = "0.4.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70" +[[package]] +name = "hex-literal" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bcaaec4551594c969335c98c903c1397853d4198408ea609190f420500f6be71" + [[package]] name = "hexf-parse" version = "0.2.1" @@ -9408,7 +9414,7 @@ dependencies = [ [[package]] name = "libwebrtc" version = "0.3.10" -source = "git+https://github.com/zed-industries/livekit-rust-sdks?rev=d2eade7a6b15d6dbdb38ba12a1ff7bf07fcebba4#d2eade7a6b15d6dbdb38ba12a1ff7bf07fcebba4" +source = "git+https://github.com/zed-industries/livekit-rust-sdks?rev=2806c1554bb2e3627ea35089208a196e19f24847#2806c1554bb2e3627ea35089208a196e19f24847" dependencies = [ "cxx", "jni", @@ -9488,7 +9494,7 @@ checksum = "23fb14cb19457329c82206317a5663005a4d404783dc74f4252769b0d5f42856" [[package]] name = "livekit" version = "0.7.8" -source = "git+https://github.com/zed-industries/livekit-rust-sdks?rev=d2eade7a6b15d6dbdb38ba12a1ff7bf07fcebba4#d2eade7a6b15d6dbdb38ba12a1ff7bf07fcebba4" +source = "git+https://github.com/zed-industries/livekit-rust-sdks?rev=2806c1554bb2e3627ea35089208a196e19f24847#2806c1554bb2e3627ea35089208a196e19f24847" dependencies = [ "chrono", "futures-util", @@ -9511,7 +9517,7 @@ dependencies = [ [[package]] name = "livekit-api" version = "0.4.2" -source = "git+https://github.com/zed-industries/livekit-rust-sdks?rev=d2eade7a6b15d6dbdb38ba12a1ff7bf07fcebba4#d2eade7a6b15d6dbdb38ba12a1ff7bf07fcebba4" +source = "git+https://github.com/zed-industries/livekit-rust-sdks?rev=2806c1554bb2e3627ea35089208a196e19f24847#2806c1554bb2e3627ea35089208a196e19f24847" dependencies = [ "futures-util", "http 0.2.12", @@ -9535,7 +9541,7 @@ dependencies = [ [[package]] name = "livekit-protocol" version = "0.3.9" -source = "git+https://github.com/zed-industries/livekit-rust-sdks?rev=d2eade7a6b15d6dbdb38ba12a1ff7bf07fcebba4#d2eade7a6b15d6dbdb38ba12a1ff7bf07fcebba4" +source = "git+https://github.com/zed-industries/livekit-rust-sdks?rev=2806c1554bb2e3627ea35089208a196e19f24847#2806c1554bb2e3627ea35089208a196e19f24847" dependencies = [ "futures-util", "livekit-runtime", @@ -9552,7 +9558,7 @@ dependencies = [ [[package]] name = "livekit-runtime" version = "0.4.0" -source = "git+https://github.com/zed-industries/livekit-rust-sdks?rev=d2eade7a6b15d6dbdb38ba12a1ff7bf07fcebba4#d2eade7a6b15d6dbdb38ba12a1ff7bf07fcebba4" +source = "git+https://github.com/zed-industries/livekit-rust-sdks?rev=2806c1554bb2e3627ea35089208a196e19f24847#2806c1554bb2e3627ea35089208a196e19f24847" dependencies = [ "tokio", "tokio-stream", @@ -18539,7 +18545,7 @@ dependencies = [ [[package]] name = "webrtc-sys" version = "0.3.7" -source = "git+https://github.com/zed-industries/livekit-rust-sdks?rev=d2eade7a6b15d6dbdb38ba12a1ff7bf07fcebba4#d2eade7a6b15d6dbdb38ba12a1ff7bf07fcebba4" +source = "git+https://github.com/zed-industries/livekit-rust-sdks?rev=2806c1554bb2e3627ea35089208a196e19f24847#2806c1554bb2e3627ea35089208a196e19f24847" dependencies = [ "cc", "cxx", @@ -18552,13 +18558,15 @@ dependencies = [ [[package]] name = "webrtc-sys-build" version = "0.3.6" -source = "git+https://github.com/zed-industries/livekit-rust-sdks?rev=d2eade7a6b15d6dbdb38ba12a1ff7bf07fcebba4#d2eade7a6b15d6dbdb38ba12a1ff7bf07fcebba4" +source = "git+https://github.com/zed-industries/livekit-rust-sdks?rev=2806c1554bb2e3627ea35089208a196e19f24847#2806c1554bb2e3627ea35089208a196e19f24847" dependencies = [ "fs2", + "hex-literal", "regex", "reqwest 0.11.27", "scratch", "semver", + "sha2", "zip", ] diff --git a/crates/livekit_client/Cargo.toml b/crates/livekit_client/Cargo.toml index a0c11d46e6..c367e03bb7 100644 --- a/crates/livekit_client/Cargo.toml +++ b/crates/livekit_client/Cargo.toml @@ -40,8 +40,8 @@ util.workspace = true workspace-hack.workspace = true [target.'cfg(not(any(all(target_os = "windows", target_env = "gnu"), target_os = "freebsd")))'.dependencies] -libwebrtc = { rev = "d2eade7a6b15d6dbdb38ba12a1ff7bf07fcebba4", git = "https://github.com/zed-industries/livekit-rust-sdks" } -livekit = { rev = "d2eade7a6b15d6dbdb38ba12a1ff7bf07fcebba4", git = "https://github.com/zed-industries/livekit-rust-sdks", features = [ +libwebrtc = { rev = "383e5377f8b7de1f8627ee16f0cf11c5293337bd", git = "https://github.com/zed-industries/livekit-rust-sdks" } +livekit = { rev = "383e5377f8b7de1f8627ee16f0cf11c5293337bd", git = "https://github.com/zed-industries/livekit-rust-sdks", features = [ "__rustls-tls" ] } From 0e7eea0d102cc39bdf1249db13dc9d5bb5ff9afd Mon Sep 17 00:00:00 2001 From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com> Date: Fri, 25 Jul 2025 14:39:33 -0300 Subject: [PATCH 062/893] Add new Nightly app icons (#35104) Release Notes: - N/A --- crates/zed/resources/app-icon-nightly.png | Bin 239870 -> 232863 bytes crates/zed/resources/app-icon-nightly@2x.png | Bin 716288 -> 848597 bytes 2 files changed, 0 insertions(+), 0 deletions(-) diff --git a/crates/zed/resources/app-icon-nightly.png b/crates/zed/resources/app-icon-nightly.png index 5f1304a6af8d57bbf7414d175611829989d122da..562588955e81265c9a44ab399d5da5813f6805fd 100644 GIT binary patch literal 232863 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

^<$;FGy0~c$pKd3l0p|9t29M|)Zg0&{qz0W3= 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