Cherry-pick bot2

open_ai: Remove model field from ResponseStreamEvent (#36902 )
Closes #36901 Release Notes: - Fixed use of Open WebUI as an LLM provider.
2025-08-25 14:38:43 -06:00 · 2025-08-25 19:50:08 +00:00 · 2025-08-25 12:45:28 -07:00 · 2025-08-25 21:07:30 +02:00 · 2025-08-25 19:02:19 +00:00 · 2025-08-25 20:51:23 +02:00
55 changed files with 1740 additions and 931 deletions
--- a/.github/workflows/cherry-pick.yml
+++ b/.github/workflows/cherry-pick.yml
@@ -0,0 +1,151 @@
+name: Cherry Pick
+
+on:
+  issue_comment:
+    types: [created]
+  pull_request_target:
+    types: [closed]
+
+jobs:
+  cherry-pick:
+    # This job will run when a PR is merged with a specific comment,
+    # or when a comment is added to an already merged PR.
+    runs-on: ubuntu-latest
+    # Use pull_request_target so that we can add comments back to the PR
+    # if the cherry-pick fails.
+    permissions:
+      pull-requests: write
+      contents: write
+      issues: write
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0 # Required to get all history for cherry-picking
+
+      - name: Extract info and determine trigger
+        id: info
+        run: |
+          # Default to failure unless a valid trigger is found
+          echo "valid=false" >> $GITHUB_OUTPUT
+
+          if [[ "${{ github.event_name }}" == "pull_request_target" && "${{ github.event.pull_request.merged }}" == "true" ]]; then
+            echo "Triggered by PR merge"
+            PR_NUMBER="${{ github.event.pull_request.number }}"
+
+            # Check PR body first, then fall back to comments
+            TEXT_TO_SEARCH="${{ github.event.pull_request.body }}"
+            if [[ ! "$TEXT_TO_SEARCH" =~ /cherry-pick[[:space:]]+(stable|preview) ]]; then
+              echo "Command not found in PR body. Checking comments..."
+              TEXT_TO_SEARCH=$(gh pr view $PR_NUMBER --json comments -q '.comments[].body' | tail -n 100)
+            fi
+
+            if [[ "$TEXT_TO_SEARCH" =~ /cherry-pick[[:space:]]+(stable|preview) ]]; then
+              echo "Found cherry-pick command."
+              MERGE_SHA="${{ github.event.pull_request.merge_commit_sha }}"
+              # Get the last matching command in the text
+              CHANNEL=$(echo "$TEXT_TO_SEARCH" | grep -oP '/cherry-pick[[:space:]]+\K(stable|preview)' | tail -n1)
+
+              echo "valid=true" >> $GITHUB_OUTPUT
+              echo "merge_sha=$MERGE_SHA" >> $GITHUB_OUTPUT
+              echo "pr_number=$PR_NUMBER" >> $GITHUB_OUTPUT
+              echo "channel=$CHANNEL" >> $GITHUB_OUTPUT
+            else
+              echo "No cherry-pick command found in PR body or recent comments. Exiting."
+              exit 0
+            fi
+
+          elif [[ "${{ github.event_name }}" == "issue_comment" && "${{ github.event.issue.pull_request }}" != "" ]]; then
+            echo "Triggered by issue comment"
+            COMMENT_BODY="${{ github.event.comment.body }}"
+            if [[ ! "$COMMENT_BODY" =~ /cherry-pick[[:space:]]+(stable|preview) ]]; then
+              echo "Comment does not contain cherry-pick command. Exiting."
+              exit 0
+            fi
+
+            PR_NUMBER="${{ github.event.issue.number }}"
+
+            # Check if the PR is merged
+            MERGE_SHA=$(gh pr view $PR_NUMBER --json mergeCommit -q .mergeCommit.oid)
+            if [[ -z "$MERGE_SHA" ]]; then
+              echo "PR #$PR_NUMBER is not merged. Exiting."
+              exit 0
+            fi
+
+            CHANNEL=$(echo "$COMMENT_BODY" | grep -oP '/cherry-pick[[:space:]]+\K(stable|preview)' | head -n1)
+
+            echo "valid=true" >> $GITHUB_OUTPUT
+            echo "merge_sha=$MERGE_SHA" >> $GITHUB_OUTPUT
+            echo "pr_number=$PR_NUMBER" >> $GITHUB_OUTPUT
+            echo "channel=$CHANNEL" >> $GITHUB_OUTPUT
+          fi
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Cherry-pick
+        if: steps.info.outputs.valid == 'true'
+        run: |
+          set -e
+
+          CHANNEL="${{ steps.info.outputs.channel }}"
+          MERGE_SHA="${{ steps.info.outputs.merge_sha }}"
+          PR_NUMBER="${{ steps.info.outputs.pr_number }}"
+
+          # Get the latest version for the channel
+          echo "Fetching latest version for '$CHANNEL' channel..."
+          query=""
+          case $CHANNEL in
+            stable)
+              ;;
+            preview)
+              query="&preview=1"
+              ;;
+            *)
+              echo "Invalid channel: $CHANNEL" >&2
+              exit 1
+              ;;
+          esac
+          LATEST_VERSION=$(curl -s "https://zed.dev/api/releases/latest?asset=zed&os=macos&arch=aarch64$query" | jq -r .version)
+
+          if [[ -z "$LATEST_VERSION" ]]; then
+            echo "Could not fetch latest version for channel '$CHANNEL'"
+            gh pr comment $PR_NUMBER --body "Could not fetch latest version for channel '$CHANNEL' from zed.dev API."
+            exit 1
+          fi
+          echo "Latest version is $LATEST_VERSION"
+
+          # Construct target branch name (e.g., v0.85.4 -> v0.85.x)
+          TARGET_BRANCH=$(echo "$LATEST_VERSION" | sed -E 's/v([0-9]+\.[0-9]+)\..*/v\1.x/')
+          echo "Target branch is $TARGET_BRANCH"
+
+          # Configure git
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+
+          # Create and push the cherry-pick branch
+          NEW_BRANCH="cherry-pick/pr-${PR_NUMBER}-to-${TARGET_BRANCH}"
+
+          git fetch origin $TARGET_BRANCH
+          git checkout -b $NEW_BRANCH "origin/$TARGET_BRANCH"
+
+          echo "Attempting to cherry-pick $MERGE_SHA..."
+          if ! git cherry-pick $MERGE_SHA; then
+            echo "Cherry-pick failed. Please resolve conflicts manually."
+            gh pr comment $PR_NUMBER --body "Automated cherry-pick to \`$TARGET_BRANCH\` failed due to conflicts. Please resolve them manually."
+            exit 1
+          fi
+
+          echo "Pushing new branch $NEW_BRANCH..."
+          git push -u origin $NEW_BRANCH
+
+          # Create the pull request
+          echo "Creating pull request..."
+          gh pr create \
+            --title "Cherry-pick PR #${PR_NUMBER} to ${TARGET_BRANCH}" \
+            --body "This PR cherry-picks the changes from #${PR_NUMBER} to the \`$TARGET_BRANCH\` branch." \
+            --base $TARGET_BRANCH \
+            --head $NEW_BRANCH \
+            --reviewer "${{ github.actor }}"
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -8468,6 +8468,7 @@ dependencies = [
 "theme",
 "ui",
 "util",
+ "util_macros",
 "workspace",
 "workspace-hack",
 "zed_actions",
--- a/assets/icons/copy.svg
+++ b/assets/icons/copy.svg
@@ -1 +1,4 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" fill="none"><path stroke="#000" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.2" d="M12.286 6H7.048C6.469 6 6 6.469 6 7.048v5.238c0 .578.469 1.047 1.048 1.047h5.238c.578 0 1.047-.469 1.047-1.047V7.048c0-.579-.469-1.048-1.047-1.048Z"/><path stroke="#000" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.2" d="M3.714 10a1.05 1.05 0 0 1-1.047-1.048V3.714a1.05 1.05 0 0 1 1.047-1.047h5.238A1.05 1.05 0 0 1 10 3.714"/></svg>
+<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M12.486 6.2H7.24795C6.66895 6.2 6.19995 6.669 6.19995 7.248V12.486C6.19995 13.064 6.66895 13.533 7.24795 13.533H12.486C13.064 13.533 13.533 13.064 13.533 12.486V7.248C13.533 6.669 13.064 6.2 12.486 6.2Z" stroke="black" stroke-width="1.2" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M3.91712 10.203C3.63951 10.2022 3.37351 10.0915 3.1773 9.89511C2.98109 9.69872 2.87064 9.43261 2.87012 9.155V3.917C2.87091 3.63956 2.98147 3.37371 3.17765 3.17753C3.37383 2.98135 3.63968 2.87079 3.91712 2.87H9.15512C9.43273 2.87053 9.69883 2.98097 9.89523 3.17718C10.0916 3.37339 10.2023 3.63939 10.2031 3.917" stroke="black" stroke-width="1.2" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>
--- a/assets/settings/default.json
+++ b/assets/settings/default.json
@@ -162,6 +162,12 @@
  //  2. Always quit the application
  //         "on_last_window_closed": "quit_app",
  "on_last_window_closed": "platform_default",
+  // Whether to show padding for zoomed panels.
+  // When enabled, zoomed center panels (e.g. code editor) will have padding all around,
+  // while zoomed bottom/left/right panels will have padding to the top/right/left (respectively).
+  //
+  // Default: true
+  "zoomed_padding": true,
  // Whether to use the system provided dialogs for Open and Save As.
  // When set to false, Zed will use the built-in keyboard-first pickers.
  "use_system_path_prompts": true,
@@ -1629,6 +1635,9 @@
        "allowed": true
      }
    },
+    "Kotlin": {
+      "language_servers": ["kotlin-language-server", "!kotlin-lsp", "..."]
+    },
    "LaTeX": {
      "formatter": "language_server",
      "language_servers": ["texlab", "..."],
--- a/crates/acp_thread/src/acp_thread.rs
+++ b/crates/acp_thread/src/acp_thread.rs
@@ -509,7 +509,7 @@ impl ContentBlock {
        "`Image`".into()
    }

-    fn to_markdown<'a>(&'a self, cx: &'a App) -> &'a str {
+    pub fn to_markdown<'a>(&'a self, cx: &'a App) -> &'a str {
        match self {
            ContentBlock::Empty => "",
            ContentBlock::Markdown { markdown } => markdown.read(cx).source(),
@@ -756,6 +756,8 @@ pub struct AcpThread {
    connection: Rc<dyn AgentConnection>,
    session_id: acp::SessionId,
    token_usage: Option<TokenUsage>,
+    prompt_capabilities: acp::PromptCapabilities,
+    _observe_prompt_capabilities: Task<anyhow::Result<()>>,
 }

 #[derive(Debug)]
@@ -770,11 +772,12 @@ pub enum AcpThreadEvent {
    Stopped,
    Error,
    LoadError(LoadError),
+    PromptCapabilitiesUpdated,
 }

 impl EventEmitter<AcpThreadEvent> for AcpThread {}

-#[derive(PartialEq, Eq)]
+#[derive(PartialEq, Eq, Debug)]
 pub enum ThreadStatus {
    Idle,
    WaitingForToolConfirmation,
@@ -821,7 +824,20 @@ impl AcpThread {
        project: Entity<Project>,
        action_log: Entity<ActionLog>,
        session_id: acp::SessionId,
+        mut prompt_capabilities_rx: watch::Receiver<acp::PromptCapabilities>,
+        cx: &mut Context<Self>,
    ) -> Self {
+        let prompt_capabilities = *prompt_capabilities_rx.borrow();
+        let task = cx.spawn::<_, anyhow::Result<()>>(async move |this, cx| {
+            loop {
+                let caps = prompt_capabilities_rx.recv().await?;
+                this.update(cx, |this, cx| {
+                    this.prompt_capabilities = caps;
+                    cx.emit(AcpThreadEvent::PromptCapabilitiesUpdated);
+                })?;
+            }
+        });
+
        Self {
            action_log,
            shared_buffers: Default::default(),
@@ -833,9 +849,15 @@ impl AcpThread {
            connection,
            session_id,
            token_usage: None,
+            prompt_capabilities,
+            _observe_prompt_capabilities: task,
        }
    }

+    pub fn prompt_capabilities(&self) -> acp::PromptCapabilities {
+        self.prompt_capabilities
+    }
+
    pub fn connection(&self) -> &Rc<dyn AgentConnection> {
        &self.connection
    }
@@ -1373,6 +1395,10 @@ impl AcpThread {
        })
    }

+    pub fn can_resume(&self, cx: &App) -> bool {
+        self.connection.resume(&self.session_id, cx).is_some()
+    }
+
    pub fn resume(&mut self, cx: &mut Context<Self>) -> BoxFuture<'static, Result<()>> {
        self.run_turn(cx, async move |this, cx| {
            this.update(cx, |this, cx| {
@@ -2595,13 +2621,19 @@ mod tests {
                    .into(),
            );
            let action_log = cx.new(|_| ActionLog::new(project.clone()));
-            let thread = cx.new(|_cx| {
+            let thread = cx.new(|cx| {
                AcpThread::new(
                    "Test",
                    self.clone(),
                    project,
                    action_log,
                    session_id.clone(),
+                    watch::Receiver::constant(acp::PromptCapabilities {
+                        image: true,
+                        audio: true,
+                        embedded_context: true,
+                    }),
+                    cx,
                )
            });
            self.sessions.lock().insert(session_id, thread.downgrade());
@@ -2635,14 +2667,6 @@ mod tests {
            }
        }

-        fn prompt_capabilities(&self) -> acp::PromptCapabilities {
-            acp::PromptCapabilities {
-                image: true,
-                audio: true,
-                embedded_context: true,
-            }
-        }
-
        fn cancel(&self, session_id: &acp::SessionId, cx: &mut App) {
            let sessions = self.sessions.lock();
            let thread = sessions.get(session_id).unwrap().clone();
@@ -2659,7 +2683,7 @@ mod tests {
        fn truncate(
            &self,
            session_id: &acp::SessionId,
-            _cx: &mut App,
+            _cx: &App,
        ) -> Option<Rc<dyn AgentSessionTruncate>> {
            Some(Rc::new(FakeAgentSessionEditor {
                _session_id: session_id.clone(),
--- a/crates/acp_thread/src/connection.rs
+++ b/crates/acp_thread/src/connection.rs
@@ -38,12 +38,10 @@ pub trait AgentConnection {
        cx: &mut App,
    ) -> Task<Result<acp::PromptResponse>>;

-    fn prompt_capabilities(&self) -> acp::PromptCapabilities;
-
    fn resume(
        &self,
        _session_id: &acp::SessionId,
-        _cx: &mut App,
+        _cx: &App,
    ) -> Option<Rc<dyn AgentSessionResume>> {
        None
    }
@@ -53,7 +51,7 @@ pub trait AgentConnection {
    fn truncate(
        &self,
        _session_id: &acp::SessionId,
-        _cx: &mut App,
+        _cx: &App,
    ) -> Option<Rc<dyn AgentSessionTruncate>> {
        None
    }
@@ -61,7 +59,7 @@ pub trait AgentConnection {
    fn set_title(
        &self,
        _session_id: &acp::SessionId,
-        _cx: &mut App,
+        _cx: &App,
    ) -> Option<Rc<dyn AgentSessionSetTitle>> {
        None
    }
@@ -329,13 +327,19 @@ mod test_support {
        ) -> Task<gpui::Result<Entity<AcpThread>>> {
            let session_id = acp::SessionId(self.sessions.lock().len().to_string().into());
            let action_log = cx.new(|_| ActionLog::new(project.clone()));
-            let thread = cx.new(|_cx| {
+            let thread = cx.new(|cx| {
                AcpThread::new(
                    "Test",
                    self.clone(),
                    project,
                    action_log,
                    session_id.clone(),
+                    watch::Receiver::constant(acp::PromptCapabilities {
+                        image: true,
+                        audio: true,
+                        embedded_context: true,
+                    }),
+                    cx,
                )
            });
            self.sessions.lock().insert(
@@ -348,14 +352,6 @@ mod test_support {
            Task::ready(Ok(thread))
        }

-        fn prompt_capabilities(&self) -> acp::PromptCapabilities {
-            acp::PromptCapabilities {
-                image: true,
-                audio: true,
-                embedded_context: true,
-            }
-        }
-
        fn authenticate(
            &self,
            _method_id: acp::AuthMethodId,
@@ -439,7 +435,7 @@ mod test_support {
        fn truncate(
            &self,
            _session_id: &agent_client_protocol::SessionId,
-            _cx: &mut App,
+            _cx: &App,
        ) -> Option<Rc<dyn AgentSessionTruncate>> {
            Some(Rc::new(StubAgentSessionEditor))
        }
--- a/crates/agent2/src/agent.rs
+++ b/crates/agent2/src/agent.rs
@@ -180,7 +180,7 @@ impl NativeAgent {
        fs: Arc<dyn Fs>,
        cx: &mut AsyncApp,
    ) -> Result<Entity<NativeAgent>> {
-        log::info!("Creating new NativeAgent");
+        log::debug!("Creating new NativeAgent");

        let project_context = cx
            .update(|cx| Self::build_project_context(&project, prompt_store.as_ref(), cx))?
@@ -240,13 +240,16 @@ impl NativeAgent {
        let title = thread.title();
        let project = thread.project.clone();
        let action_log = thread.action_log.clone();
-        let acp_thread = cx.new(|_cx| {
+        let prompt_capabilities_rx = thread.prompt_capabilities_rx.clone();
+        let acp_thread = cx.new(|cx| {
            acp_thread::AcpThread::new(
                title,
                connection,
                project.clone(),
                action_log.clone(),
                session_id.clone(),
+                prompt_capabilities_rx,
+                cx,
            )
        });
        let subscriptions = vec![
@@ -756,7 +759,7 @@ impl NativeAgentConnection {
                }
            }

-            log::info!("Response stream completed");
+            log::debug!("Response stream completed");
            anyhow::Ok(acp::PromptResponse {
                stop_reason: acp::StopReason::EndTurn,
            })
@@ -781,7 +784,7 @@ impl AgentModelSelector for NativeAgentConnection {
        model_id: acp_thread::AgentModelId,
        cx: &mut App,
    ) -> Task<Result<()>> {
-        log::info!("Setting model for session {}: {}", session_id, model_id);
+        log::debug!("Setting model for session {}: {}", session_id, model_id);
        let Some(thread) = self
            .0
            .read(cx)
@@ -852,7 +855,7 @@ impl acp_thread::AgentConnection for NativeAgentConnection {
        cx: &mut App,
    ) -> Task<Result<Entity<acp_thread::AcpThread>>> {
        let agent = self.0.clone();
-        log::info!("Creating new thread for project at: {:?}", cwd);
+        log::debug!("Creating new thread for project at: {:?}", cwd);

        cx.spawn(async move |cx| {
            log::debug!("Starting thread creation in async context");
@@ -917,7 +920,7 @@ impl acp_thread::AgentConnection for NativeAgentConnection {
                .into_iter()
                .map(Into::into)
                .collect::<Vec<_>>();
-            log::info!("Converted prompt to message: {} chars", content.len());
+            log::debug!("Converted prompt to message: {} chars", content.len());
            log::debug!("Message id: {:?}", id);
            log::debug!("Message content: {:?}", content);

@@ -925,18 +928,10 @@ impl acp_thread::AgentConnection for NativeAgentConnection {
        })
    }

-    fn prompt_capabilities(&self) -> acp::PromptCapabilities {
-        acp::PromptCapabilities {
-            image: true,
-            audio: false,
-            embedded_context: true,
-        }
-    }
-
    fn resume(
        &self,
        session_id: &acp::SessionId,
-        _cx: &mut App,
+        _cx: &App,
    ) -> Option<Rc<dyn acp_thread::AgentSessionResume>> {
        Some(Rc::new(NativeAgentSessionResume {
            connection: self.clone(),
@@ -956,9 +951,9 @@ impl acp_thread::AgentConnection for NativeAgentConnection {
    fn truncate(
        &self,
        session_id: &agent_client_protocol::SessionId,
-        cx: &mut App,
+        cx: &App,
    ) -> Option<Rc<dyn acp_thread::AgentSessionTruncate>> {
-        self.0.update(cx, |agent, _cx| {
+        self.0.read_with(cx, |agent, _cx| {
            agent.sessions.get(session_id).map(|session| {
                Rc::new(NativeAgentSessionEditor {
                    thread: session.thread.clone(),
@@ -971,7 +966,7 @@ impl acp_thread::AgentConnection for NativeAgentConnection {
    fn set_title(
        &self,
        session_id: &acp::SessionId,
-        _cx: &mut App,
+        _cx: &App,
    ) -> Option<Rc<dyn acp_thread::AgentSessionSetTitle>> {
        Some(Rc::new(NativeAgentSessionSetTitle {
            connection: self.clone(),
--- a/crates/agent2/src/native_agent_server.rs
+++ b/crates/agent2/src/native_agent_server.rs
@@ -22,6 +22,10 @@ impl NativeAgentServer {
 }

 impl AgentServer for NativeAgentServer {
+    fn telemetry_id(&self) -> &'static str {
+        "zed"
+    }
+
    fn name(&self) -> SharedString {
        "Zed Agent".into()
    }
@@ -44,7 +48,7 @@ impl AgentServer for NativeAgentServer {
        project: &Entity<Project>,
        cx: &mut App,
    ) -> Task<Result<Rc<dyn acp_thread::AgentConnection>>> {
-        log::info!(
+        log::debug!(
            "NativeAgentServer::connect called for path: {:?}",
            _root_dir
        );
@@ -63,7 +67,7 @@ impl AgentServer for NativeAgentServer {

            // Create the connection wrapper
            let connection = NativeAgentConnection(agent);
-            log::info!("NativeAgentServer connection established successfully");
+            log::debug!("NativeAgentServer connection established successfully");

            Ok(Rc::new(connection) as Rc<dyn acp_thread::AgentConnection>)
        })
--- a/crates/agent2/src/tests/mod.rs
+++ b/crates/agent2/src/tests/mod.rs
@@ -4,6 +4,8 @@ use agent_client_protocol::{self as acp};
 use agent_settings::AgentProfileId;
 use anyhow::Result;
 use client::{Client, UserStore};
+use cloud_llm_client::CompletionIntent;
+use collections::IndexMap;
 use context_server::{ContextServer, ContextServerCommand, ContextServerId};
 use fs::{FakeFs, Fs};
 use futures::{
@@ -672,15 +674,6 @@ async fn test_resume_after_tool_use_limit(cx: &mut TestAppContext) {
            "}
        )
    });
-
-    // Ensure we error if calling resume when tool use limit was *not* reached.
-    let error = thread
-        .update(cx, |thread, cx| thread.resume(cx))
-        .unwrap_err();
-    assert_eq!(
-        error.to_string(),
-        "can only resume after tool use limit is reached"
-    )
 }

 #[gpui::test]
@@ -1692,6 +1685,7 @@ async fn test_truncate_second_message(cx: &mut TestAppContext) {
 }

 #[gpui::test]
+#[cfg_attr(target_os = "windows", ignore)] // TODO: Fix this test on Windows
 async fn test_title_generation(cx: &mut TestAppContext) {
    let ThreadTest { model, thread, .. } = setup(cx, TestModel::Fake).await;
    let fake_model = model.as_fake();
@@ -1737,6 +1731,81 @@ async fn test_title_generation(cx: &mut TestAppContext) {
    thread.read_with(cx, |thread, _| assert_eq!(thread.title(), "Hello world"));
 }

+#[gpui::test]
+async fn test_building_request_with_pending_tools(cx: &mut TestAppContext) {
+    let ThreadTest { model, thread, .. } = setup(cx, TestModel::Fake).await;
+    let fake_model = model.as_fake();
+
+    let _events = thread
+        .update(cx, |thread, cx| {
+            thread.add_tool(ToolRequiringPermission);
+            thread.add_tool(EchoTool);
+            thread.send(UserMessageId::new(), ["Hey!"], cx)
+        })
+        .unwrap();
+    cx.run_until_parked();
+
+    let permission_tool_use = LanguageModelToolUse {
+        id: "tool_id_1".into(),
+        name: ToolRequiringPermission::name().into(),
+        raw_input: "{}".into(),
+        input: json!({}),
+        is_input_complete: true,
+    };
+    let echo_tool_use = LanguageModelToolUse {
+        id: "tool_id_2".into(),
+        name: EchoTool::name().into(),
+        raw_input: json!({"text": "test"}).to_string(),
+        input: json!({"text": "test"}),
+        is_input_complete: true,
+    };
+    fake_model.send_last_completion_stream_text_chunk("Hi!");
+    fake_model.send_last_completion_stream_event(LanguageModelCompletionEvent::ToolUse(
+        permission_tool_use,
+    ));
+    fake_model.send_last_completion_stream_event(LanguageModelCompletionEvent::ToolUse(
+        echo_tool_use.clone(),
+    ));
+    fake_model.end_last_completion_stream();
+    cx.run_until_parked();
+
+    // Ensure pending tools are skipped when building a request.
+    let request = thread
+        .read_with(cx, |thread, cx| {
+            thread.build_completion_request(CompletionIntent::EditFile, cx)
+        })
+        .unwrap();
+    assert_eq!(
+        request.messages[1..],
+        vec![
+            LanguageModelRequestMessage {
+                role: Role::User,
+                content: vec!["Hey!".into()],
+                cache: true
+            },
+            LanguageModelRequestMessage {
+                role: Role::Assistant,
+                content: vec![
+                    MessageContent::Text("Hi!".into()),
+                    MessageContent::ToolUse(echo_tool_use.clone())
+                ],
+                cache: false
+            },
+            LanguageModelRequestMessage {
+                role: Role::User,
+                content: vec![MessageContent::ToolResult(LanguageModelToolResult {
+                    tool_use_id: echo_tool_use.id.clone(),
+                    tool_name: echo_tool_use.name,
+                    is_error: false,
+                    content: "test".into(),
+                    output: Some("test".into())
+                })],
+                cache: false
+            },
+        ],
+    );
+}
+
 #[gpui::test]
 async fn test_agent_connection(cx: &mut TestAppContext) {
    cx.update(settings::init);
@@ -2029,6 +2098,7 @@ async fn test_send_retry_on_error(cx: &mut TestAppContext) {
        .unwrap();
    cx.run_until_parked();

+    fake_model.send_last_completion_stream_text_chunk("Hey,");
    fake_model.send_last_completion_stream_error(LanguageModelCompletionError::ServerOverloaded {
        provider: LanguageModelProviderName::new("Anthropic"),
        retry_after: Some(Duration::from_secs(3)),
@@ -2038,8 +2108,9 @@ async fn test_send_retry_on_error(cx: &mut TestAppContext) {
    cx.executor().advance_clock(Duration::from_secs(3));
    cx.run_until_parked();

-    fake_model.send_last_completion_stream_text_chunk("Hey!");
+    fake_model.send_last_completion_stream_text_chunk("there!");
    fake_model.end_last_completion_stream();
+    cx.run_until_parked();

    let mut retry_events = Vec::new();
    while let Some(Ok(event)) = events.next().await {
@@ -2067,12 +2138,94 @@ async fn test_send_retry_on_error(cx: &mut TestAppContext) {

                ## Assistant

-                Hey!
+                Hey,
+
+                [resume]
+
+                ## Assistant
+
+                there!
            "}
        )
    });
 }

+#[gpui::test]
+async fn test_send_retry_finishes_tool_calls_on_error(cx: &mut TestAppContext) {
+    let ThreadTest { thread, model, .. } = setup(cx, TestModel::Fake).await;
+    let fake_model = model.as_fake();
+
+    let events = thread
+        .update(cx, |thread, cx| {
+            thread.set_completion_mode(agent_settings::CompletionMode::Burn, cx);
+            thread.add_tool(EchoTool);
+            thread.send(UserMessageId::new(), ["Call the echo tool!"], cx)
+        })
+        .unwrap();
+    cx.run_until_parked();
+
+    let tool_use_1 = LanguageModelToolUse {
+        id: "tool_1".into(),
+        name: EchoTool::name().into(),
+        raw_input: json!({"text": "test"}).to_string(),
+        input: json!({"text": "test"}),
+        is_input_complete: true,
+    };
+    fake_model.send_last_completion_stream_event(LanguageModelCompletionEvent::ToolUse(
+        tool_use_1.clone(),
+    ));
+    fake_model.send_last_completion_stream_error(LanguageModelCompletionError::ServerOverloaded {
+        provider: LanguageModelProviderName::new("Anthropic"),
+        retry_after: Some(Duration::from_secs(3)),
+    });
+    fake_model.end_last_completion_stream();
+
+    cx.executor().advance_clock(Duration::from_secs(3));
+    let completion = fake_model.pending_completions().pop().unwrap();
+    assert_eq!(
+        completion.messages[1..],
+        vec![
+            LanguageModelRequestMessage {
+                role: Role::User,
+                content: vec!["Call the echo tool!".into()],
+                cache: false
+            },
+            LanguageModelRequestMessage {
+                role: Role::Assistant,
+                content: vec![language_model::MessageContent::ToolUse(tool_use_1.clone())],
+                cache: false
+            },
+            LanguageModelRequestMessage {
+                role: Role::User,
+                content: vec![language_model::MessageContent::ToolResult(
+                    LanguageModelToolResult {
+                        tool_use_id: tool_use_1.id.clone(),
+                        tool_name: tool_use_1.name.clone(),
+                        is_error: false,
+                        content: "test".into(),
+                        output: Some("test".into())
+                    }
+                )],
+                cache: true
+            },
+        ]
+    );
+
+    fake_model.send_last_completion_stream_text_chunk("Done");
+    fake_model.end_last_completion_stream();
+    cx.run_until_parked();
+    events.collect::<Vec<_>>().await;
+    thread.read_with(cx, |thread, _cx| {
+        assert_eq!(
+            thread.last_message(),
+            Some(Message::Agent(AgentMessage {
+                content: vec![AgentMessageContent::Text("Done".into())],
+                tool_results: IndexMap::default()
+            }))
+        );
+    })
+}
+
 #[gpui::test]
 async fn test_send_max_retries_exceeded(cx: &mut TestAppContext) {
    let ThreadTest { thread, model, .. } = setup(cx, TestModel::Fake).await;
--- a/crates/agent2/src/thread.rs
+++ b/crates/agent2/src/thread.rs
@@ -123,7 +123,7 @@ impl Message {
        match self {
            Message::User(message) => message.to_markdown(),
            Message::Agent(message) => message.to_markdown(),
-            Message::Resume => "[resumed after tool use limit was reached]".into(),
+            Message::Resume => "[resume]\n".into(),
        }
    }

@@ -448,24 +448,33 @@ impl AgentMessage {
            cache: false,
        };
        for chunk in &self.content {
-            let chunk = match chunk {
+            match chunk {
                AgentMessageContent::Text(text) => {
-                    language_model::MessageContent::Text(text.clone())
+                    assistant_message
+                        .content
+                        .push(language_model::MessageContent::Text(text.clone()));
                }
                AgentMessageContent::Thinking { text, signature } => {
-                    language_model::MessageContent::Thinking {
-                        text: text.clone(),
-                        signature: signature.clone(),
-                    }
+                    assistant_message
+                        .content
+                        .push(language_model::MessageContent::Thinking {
+                            text: text.clone(),
+                            signature: signature.clone(),
+                        });
                }
                AgentMessageContent::RedactedThinking(value) => {
-                    language_model::MessageContent::RedactedThinking(value.clone())
+                    assistant_message.content.push(
+                        language_model::MessageContent::RedactedThinking(value.clone()),
+                    );
                }
-                AgentMessageContent::ToolUse(value) => {
-                    language_model::MessageContent::ToolUse(value.clone())
+                AgentMessageContent::ToolUse(tool_use) => {
+                    if self.tool_results.contains_key(&tool_use.id) {
+                        assistant_message
+                            .content
+                            .push(language_model::MessageContent::ToolUse(tool_use.clone()));
+                    }
                }
            };
-            assistant_message.content.push(chunk);
        }

        let mut user_message = LanguageModelRequestMessage {
@@ -566,11 +575,22 @@ pub struct Thread {
    templates: Arc<Templates>,
    model: Option<Arc<dyn LanguageModel>>,
    summarization_model: Option<Arc<dyn LanguageModel>>,
+    prompt_capabilities_tx: watch::Sender<acp::PromptCapabilities>,
+    pub(crate) prompt_capabilities_rx: watch::Receiver<acp::PromptCapabilities>,
    pub(crate) project: Entity<Project>,
    pub(crate) action_log: Entity<ActionLog>,
 }

 impl Thread {
+    fn prompt_capabilities(model: Option<&dyn LanguageModel>) -> acp::PromptCapabilities {
+        let image = model.map_or(true, |model| model.supports_images());
+        acp::PromptCapabilities {
+            image,
+            audio: false,
+            embedded_context: true,
+        }
+    }
+
    pub fn new(
        project: Entity<Project>,
        project_context: Entity<ProjectContext>,
@@ -581,6 +601,8 @@ impl Thread {
    ) -> Self {
        let profile_id = AgentSettings::get_global(cx).default_profile.clone();
        let action_log = cx.new(|_cx| ActionLog::new(project.clone()));
+        let (prompt_capabilities_tx, prompt_capabilities_rx) =
+            watch::channel(Self::prompt_capabilities(model.as_deref()));
        Self {
            id: acp::SessionId(uuid::Uuid::new_v4().to_string().into()),
            prompt_id: PromptId::new(),
@@ -608,6 +630,8 @@ impl Thread {
            templates,
            model,
            summarization_model: None,
+            prompt_capabilities_tx,
+            prompt_capabilities_rx,
            project,
            action_log,
        }
@@ -741,6 +765,8 @@ impl Thread {
                .or_else(|| registry.default_model())
                .map(|model| model.model)
        });
+        let (prompt_capabilities_tx, prompt_capabilities_rx) =
+            watch::channel(Self::prompt_capabilities(model.as_deref()));

        Self {
            id,
@@ -770,6 +796,8 @@ impl Thread {
            project,
            action_log,
            updated_at: db_thread.updated_at,
+            prompt_capabilities_tx,
+            prompt_capabilities_rx,
        }
    }

@@ -937,10 +965,12 @@ impl Thread {
    pub fn set_model(&mut self, model: Arc<dyn LanguageModel>, cx: &mut Context<Self>) {
        let old_usage = self.latest_token_usage();
        self.model = Some(model);
+        let new_caps = Self::prompt_capabilities(self.model.as_deref());
        let new_usage = self.latest_token_usage();
        if old_usage != new_usage {
            cx.emit(TokenUsageUpdated(new_usage));
        }
+        self.prompt_capabilities_tx.send(new_caps).log_err();
        cx.notify()
    }

@@ -1076,15 +1106,10 @@ impl Thread {
        &mut self,
        cx: &mut Context<Self>,
    ) -> Result<mpsc::UnboundedReceiver<Result<ThreadEvent>>> {
-        anyhow::ensure!(
-            self.tool_use_limit_reached,
-            "can only resume after tool use limit is reached"
-        );
-
        self.messages.push(Message::Resume);
        cx.notify();

-        log::info!("Total messages in thread: {}", self.messages.len());
+        log::debug!("Total messages in thread: {}", self.messages.len());
        self.run_turn(cx)
    }

@@ -1102,7 +1127,7 @@ impl Thread {
    {
        let model = self.model().context("No language model configured")?;

-        log::info!("Thread::send called with model: {:?}", model.name());
+        log::info!("Thread::send called with model: {}", model.name().0);
        self.advance_prompt_id();

        let content = content.into_iter().map(Into::into).collect::<Vec<_>>();
@@ -1112,7 +1137,7 @@ impl Thread {
            .push(Message::User(UserMessage { id, content }));
        cx.notify();

-        log::info!("Total messages in thread: {}", self.messages.len());
+        log::debug!("Total messages in thread: {}", self.messages.len());
        self.run_turn(cx)
    }

@@ -1136,44 +1161,14 @@ impl Thread {
            event_stream: event_stream.clone(),
            tools: self.enabled_tools(profile, &model, cx),
            _task: cx.spawn(async move |this, cx| {
-                log::info!("Starting agent turn execution");
+                log::debug!("Starting agent turn execution");

-                let turn_result: Result<()> = async {
-                    let mut intent = CompletionIntent::UserPrompt;
-                    loop {
-                        Self::stream_completion(&this, &model, intent, &event_stream, cx).await?;
-
-                        let mut end_turn = true;
-                        this.update(cx, |this, cx| {
-                            // Generate title if needed.
-                            if this.title.is_none() && this.pending_title_generation.is_none() {
-                                this.generate_title(cx);
-                            }
-
-                            // End the turn if the model didn't use tools.
-                            let message = this.pending_message.as_ref();
-                            end_turn =
-                                message.map_or(true, |message| message.tool_results.is_empty());
-                            this.flush_pending_message(cx);
-                        })?;
-
-                        if this.read_with(cx, |this, _| this.tool_use_limit_reached)? {
-                            log::info!("Tool use limit reached, completing turn");
-                            return Err(language_model::ToolUseLimitReachedError.into());
-                        } else if end_turn {
-                            log::info!("No tool uses found, completing turn");
-                            return Ok(());
-                        } else {
-                            intent = CompletionIntent::ToolResults;
-                        }
-                    }
-                }
-                .await;
+                let turn_result = Self::run_turn_internal(&this, model, &event_stream, cx).await;
                _ = this.update(cx, |this, cx| this.flush_pending_message(cx));

                match turn_result {
                    Ok(()) => {
-                        log::info!("Turn execution completed");
+                        log::debug!("Turn execution completed");
                        event_stream.send_stop(acp::StopReason::EndTurn);
                    }
                    Err(error) => {
@@ -1199,20 +1194,18 @@ impl Thread {
        Ok(events_rx)
    }

-    async fn stream_completion(
+    async fn run_turn_internal(
        this: &WeakEntity<Self>,
-        model: &Arc<dyn LanguageModel>,
-        completion_intent: CompletionIntent,
+        model: Arc<dyn LanguageModel>,
        event_stream: &ThreadEventStream,
        cx: &mut AsyncApp,
    ) -> Result<()> {
-        log::debug!("Stream completion started successfully");
-        let request = this.update(cx, |this, cx| {
-            this.build_completion_request(completion_intent, cx)
-        })??;
+        let mut attempt = 0;
+        let mut intent = CompletionIntent::UserPrompt;
+        loop {
+            let request =
+                this.update(cx, |this, cx| this.build_completion_request(intent, cx))??;

-        let mut attempt = None;
-        'retry: loop {
            telemetry::event!(
                "Agent Thread Completion",
                thread_id = this.read_with(cx, |this, _| this.id.to_string())?,
@@ -1222,75 +1215,31 @@ impl Thread {
                attempt
            );

-            log::info!(
-                "Calling model.stream_completion, attempt {}",
-                attempt.unwrap_or(0)
-            );
+            log::debug!("Calling model.stream_completion, attempt {}", attempt);
            let mut events = model
-                .stream_completion(request.clone(), cx)
+                .stream_completion(request, cx)
                .await
                .map_err(|error| anyhow!(error))?;
            let mut tool_results = FuturesUnordered::new();
-
+            let mut error = None;
            while let Some(event) = events.next().await {
+                log::trace!("Received completion event: {:?}", event);
                match event {
                    Ok(event) => {
-                        log::trace!("Received completion event: {:?}", event);
                        tool_results.extend(this.update(cx, |this, cx| {
-                            this.handle_streamed_completion_event(event, event_stream, cx)
+                            this.handle_completion_event(event, event_stream, cx)
                        })??);
                    }
-                    Err(error) => {
-                        let completion_mode =
-                            this.read_with(cx, |thread, _cx| thread.completion_mode())?;
-                        if completion_mode == CompletionMode::Normal {
-                            return Err(anyhow!(error))?;
-                        }
-
-                        let Some(strategy) = Self::retry_strategy_for(&error) else {
-                            return Err(anyhow!(error))?;
-                        };
-
-                        let max_attempts = match &strategy {
-                            RetryStrategy::ExponentialBackoff { max_attempts, .. } => *max_attempts,
-                            RetryStrategy::Fixed { max_attempts, .. } => *max_attempts,
-                        };
-
-                        let attempt = attempt.get_or_insert(0u8);
-
-                        *attempt += 1;
-
-                        let attempt = *attempt;
-                        if attempt > max_attempts {
-                            return Err(anyhow!(error))?;
-                        }
-
-                        let delay = match &strategy {
-                            RetryStrategy::ExponentialBackoff { initial_delay, .. } => {
-                                let delay_secs =
-                                    initial_delay.as_secs() * 2u64.pow((attempt - 1) as u32);
-                                Duration::from_secs(delay_secs)
-                            }
-                            RetryStrategy::Fixed { delay, .. } => *delay,
-                        };
-                        log::debug!("Retry attempt {attempt} with delay {delay:?}");
-
-                        event_stream.send_retry(acp_thread::RetryStatus {
-                            last_error: error.to_string().into(),
-                            attempt: attempt as usize,
-                            max_attempts: max_attempts as usize,
-                            started_at: Instant::now(),
-                            duration: delay,
-                        });
-
-                        cx.background_executor().timer(delay).await;
-                        continue 'retry;
+                    Err(err) => {
+                        error = Some(err);
+                        break;
                    }
                }
            }

+            let end_turn = tool_results.is_empty();
            while let Some(tool_result) = tool_results.next().await {
-                log::info!("Tool finished {:?}", tool_result);
+                log::debug!("Tool finished {:?}", tool_result);

                event_stream.update_tool_call_fields(
                    &tool_result.tool_use_id,
@@ -1311,31 +1260,83 @@ impl Thread {
                })?;
            }

-            return Ok(());
+            this.update(cx, |this, cx| {
+                this.flush_pending_message(cx);
+                if this.title.is_none() && this.pending_title_generation.is_none() {
+                    this.generate_title(cx);
+                }
+            })?;
+
+            if let Some(error) = error {
+                attempt += 1;
+                let retry =
+                    this.update(cx, |this, _| this.handle_completion_error(error, attempt))??;
+                let timer = cx.background_executor().timer(retry.duration);
+                event_stream.send_retry(retry);
+                timer.await;
+                this.update(cx, |this, _cx| {
+                    if let Some(Message::Agent(message)) = this.messages.last() {
+                        if message.tool_results.is_empty() {
+                            intent = CompletionIntent::UserPrompt;
+                            this.messages.push(Message::Resume);
+                        }
+                    }
+                })?;
+            } else if this.read_with(cx, |this, _| this.tool_use_limit_reached)? {
+                return Err(language_model::ToolUseLimitReachedError.into());
+            } else if end_turn {
+                return Ok(());
+            } else {
+                intent = CompletionIntent::ToolResults;
+                attempt = 0;
+            }
        }
    }

-    pub fn build_system_message(&self, cx: &App) -> LanguageModelRequestMessage {
-        log::debug!("Building system message");
-        let prompt = SystemPromptTemplate {
-            project: self.project_context.read(cx),
-            available_tools: self.tools.keys().cloned().collect(),
+    fn handle_completion_error(
+        &mut self,
+        error: LanguageModelCompletionError,
+        attempt: u8,
+    ) -> Result<acp_thread::RetryStatus> {
+        if self.completion_mode == CompletionMode::Normal {
+            return Err(anyhow!(error));
        }
-        .render(&self.templates)
-        .context("failed to build system prompt")
-        .expect("Invalid template");
-        log::debug!("System message built");
-        LanguageModelRequestMessage {
-            role: Role::System,
-            content: vec![prompt.into()],
-            cache: true,
+
+        let Some(strategy) = Self::retry_strategy_for(&error) else {
+            return Err(anyhow!(error));
+        };
+
+        let max_attempts = match &strategy {
+            RetryStrategy::ExponentialBackoff { max_attempts, .. } => *max_attempts,
+            RetryStrategy::Fixed { max_attempts, .. } => *max_attempts,
+        };
+
+        if attempt > max_attempts {
+            return Err(anyhow!(error));
        }
+
+        let delay = match &strategy {
+            RetryStrategy::ExponentialBackoff { initial_delay, .. } => {
+                let delay_secs = initial_delay.as_secs() * 2u64.pow((attempt - 1) as u32);
+                Duration::from_secs(delay_secs)
+            }
+            RetryStrategy::Fixed { delay, .. } => *delay,
+        };
+        log::debug!("Retry attempt {attempt} with delay {delay:?}");
+
+        Ok(acp_thread::RetryStatus {
+            last_error: error.to_string().into(),
+            attempt: attempt as usize,
+            max_attempts: max_attempts as usize,
+            started_at: Instant::now(),
+            duration: delay,
+        })
    }

    /// A helper method that's called on every streamed completion event.
    /// Returns an optional tool result task, which the main agentic loop will
    /// send back to the model when it resolves.
-    fn handle_streamed_completion_event(
+    fn handle_completion_event(
        &mut self,
        event: LanguageModelCompletionEvent,
        event_stream: &ThreadEventStream,
@@ -1530,7 +1531,7 @@ impl Thread {
        });
        let supports_images = self.model().is_some_and(|model| model.supports_images());
        let tool_result = tool.run(tool_use.input, tool_event_stream, cx);
-        log::info!("Running tool {}", tool_use.name);
+        log::debug!("Running tool {}", tool_use.name);
        Some(cx.foreground_executor().spawn(async move {
            let tool_result = tool_result.await.and_then(|output| {
                if let LanguageModelToolResultContent::Image(_) = &output.llm_output
@@ -1642,7 +1643,7 @@ impl Thread {
                summary.extend(lines.next());
            }

-            log::info!("Setting summary: {}", summary);
+            log::debug!("Setting summary: {}", summary);
            let summary = SharedString::from(summary);

            this.update(cx, |this, cx| {
@@ -1659,7 +1660,7 @@ impl Thread {
            return;
        };

-        log::info!(
+        log::debug!(
            "Generating title with model: {:?}",
            self.summarization_model.as_ref().map(|model| model.name())
        );
@@ -1745,6 +1746,10 @@ impl Thread {
            return;
        };

+        if message.content.is_empty() {
+            return;
+        }
+
        for content in &message.content {
            let AgentMessageContent::ToolUse(tool_use) = content else {
                continue;
@@ -1773,7 +1778,7 @@ impl Thread {
    pub(crate) fn build_completion_request(
        &self,
        completion_intent: CompletionIntent,
-        cx: &mut App,
+        cx: &App,
    ) -> Result<LanguageModelRequest> {
        let model = self.model().context("No language model configured")?;
        let tools = if let Some(turn) = self.running_turn.as_ref() {
@@ -1797,8 +1802,8 @@ impl Thread {
        log::debug!("Completion mode: {:?}", self.completion_mode);

        let messages = self.build_request_messages(cx);
-        log::info!("Request will include {} messages", messages.len());
-        log::info!("Request includes {} tools", tools.len());
+        log::debug!("Request will include {} messages", messages.len());
+        log::debug!("Request includes {} tools", tools.len());

        let request = LanguageModelRequest {
            thread_id: Some(self.id.to_string()),
@@ -1894,21 +1899,29 @@ impl Thread {
            "Building request messages from {} thread messages",
            self.messages.len()
        );
-        let mut messages = vec![self.build_system_message(cx)];
+
+        let system_prompt = SystemPromptTemplate {
+            project: self.project_context.read(cx),
+            available_tools: self.tools.keys().cloned().collect(),
+        }
+        .render(&self.templates)
+        .context("failed to build system prompt")
+        .expect("Invalid template");
+        let mut messages = vec![LanguageModelRequestMessage {
+            role: Role::System,
+            content: vec![system_prompt.into()],
+            cache: false,
+        }];
        for message in &self.messages {
            messages.extend(message.to_request());
        }

-        if let Some(message) = self.pending_message.as_ref() {
-            messages.extend(message.to_request());
+        if let Some(last_message) = messages.last_mut() {
+            last_message.cache = true;
        }

-        if let Some(last_user_message) = messages
-            .iter_mut()
-            .rev()
-            .find(|message| message.role == Role::User)
-        {
-            last_user_message.cache = true;
+        if let Some(message) = self.pending_message.as_ref() {
+            messages.extend(message.to_request());
        }

        messages
--- a/crates/agent2/src/tools/fetch_tool.rs
+++ b/crates/agent2/src/tools/fetch_tool.rs
@@ -136,12 +136,17 @@ impl AgentTool for FetchTool {
    fn run(
        self: Arc<Self>,
        input: Self::Input,
-        _event_stream: ToolCallEventStream,
+        event_stream: ToolCallEventStream,
        cx: &mut App,
    ) -> Task<Result<Self::Output>> {
+        let authorize = event_stream.authorize(input.url.clone(), cx);
+
        let text = cx.background_spawn({
            let http_client = self.http_client.clone();
-            async move { Self::build_message(http_client, &input.url).await }
+            async move {
+                authorize.await?;
+                Self::build_message(http_client, &input.url).await
+            }
        });

        cx.foreground_executor().spawn(async move {
--- a/crates/agent2/src/tools/find_path_tool.rs
+++ b/crates/agent2/src/tools/find_path_tool.rs
@@ -165,16 +165,17 @@ fn search_paths(glob: &str, project: Entity<Project>, cx: &mut App) -> Task<Resu
        .collect();

    cx.background_spawn(async move {
-        Ok(snapshots
-            .iter()
-            .flat_map(|snapshot| {
+        let mut results = Vec::new();
+        for snapshot in snapshots {
+            for entry in snapshot.entries(false, 0) {
                let root_name = PathBuf::from(snapshot.root_name());
-                snapshot
-                    .entries(false, 0)
-                    .map(move |entry| root_name.join(&entry.path))
-                    .filter(|path| path_matcher.is_match(&path))
-            })
-            .collect())
+                if path_matcher.is_match(root_name.join(&entry.path)) {
+                    results.push(snapshot.abs_path().join(entry.path.as_ref()));
+                }
+            }
+        }
+
+        Ok(results)
    })
 }

@@ -215,8 +216,8 @@ mod test {
        assert_eq!(
            matches,
            &[
-                PathBuf::from("root/apple/banana/carrot"),
-                PathBuf::from("root/apple/bandana/carbonara")
+                PathBuf::from(path!("/root/apple/banana/carrot")),
+                PathBuf::from(path!("/root/apple/bandana/carbonara"))
            ]
        );

@@ -227,8 +228,8 @@ mod test {
        assert_eq!(
            matches,
            &[
-                PathBuf::from("root/apple/banana/carrot"),
-                PathBuf::from("root/apple/bandana/carbonara")
+                PathBuf::from(path!("/root/apple/banana/carrot")),
+                PathBuf::from(path!("/root/apple/bandana/carbonara"))
            ]
        );
    }
--- a/crates/agent2/src/tools/read_file_tool.rs
+++ b/crates/agent2/src/tools/read_file_tool.rs
@@ -10,7 +10,7 @@ use project::{AgentLocation, ImageItem, Project, WorktreeSettings, image_store};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use settings::Settings;
-use std::sync::Arc;
+use std::{path::Path, sync::Arc};

 use crate::{AgentTool, ToolCallEventStream};

@@ -68,27 +68,12 @@ impl AgentTool for ReadFileTool {
    }

    fn initial_title(&self, input: Result<Self::Input, serde_json::Value>) -> SharedString {
-        if let Ok(input) = input {
-            let path = &input.path;
-            match (input.start_line, input.end_line) {
-                (Some(start), Some(end)) => {
-                    format!(
-                        "[Read file `{}` (lines {}-{})](@selection:{}:({}-{}))",
-                        path, start, end, path, start, end
-                    )
-                }
-                (Some(start), None) => {
-                    format!(
-                        "[Read file `{}` (from line {})](@selection:{}:({}-{}))",
-                        path, start, path, start, start
-                    )
-                }
-                _ => format!("[Read file `{}`](@file:{})", path, path),
-            }
-            .into()
-        } else {
-            "Read file".into()
-        }
+        input
+            .ok()
+            .as_ref()
+            .and_then(|input| Path::new(&input.path).file_name())
+            .map(|file_name| file_name.to_string_lossy().to_string().into())
+            .unwrap_or_default()
    }

    fn run(
--- a/crates/agent_servers/src/acp.rs
+++ b/crates/agent_servers/src/acp.rs
@@ -185,13 +185,16 @@ impl AgentConnection for AcpConnection {

            let session_id = response.session_id;
            let action_log = cx.new(|_| ActionLog::new(project.clone()))?;
-            let thread = cx.new(|_cx| {
+            let thread = cx.new(|cx| {
                AcpThread::new(
                    self.server_name.clone(),
                    self.clone(),
                    project,
                    action_log,
                    session_id.clone(),
+                    // ACP doesn't currently support per-session prompt capabilities or changing capabilities dynamically.
+                    watch::Receiver::constant(self.prompt_capabilities),
+                    cx,
                )
            })?;

@@ -279,10 +282,6 @@ impl AgentConnection for AcpConnection {
        })
    }

-    fn prompt_capabilities(&self) -> acp::PromptCapabilities {
-        self.prompt_capabilities
-    }
-
    fn cancel(&self, session_id: &acp::SessionId, cx: &mut App) {
        if let Some(session) = self.sessions.borrow_mut().get_mut(session_id) {
            session.suppress_abort_err = true;
--- a/crates/agent_servers/src/agent_servers.rs
+++ b/crates/agent_servers/src/agent_servers.rs
@@ -36,6 +36,7 @@ pub trait AgentServer: Send {
    fn name(&self) -> SharedString;
    fn empty_state_headline(&self) -> SharedString;
    fn empty_state_message(&self) -> SharedString;
+    fn telemetry_id(&self) -> &'static str;

    fn connect(
        &self,
@@ -97,7 +98,7 @@ pub struct AgentServerCommand {
 }

 impl AgentServerCommand {
-    pub(crate) async fn resolve(
+    pub async fn resolve(
        path_bin_name: &'static str,
        extra_args: &[&'static str],
        fallback_path: Option<&Path>,
--- a/crates/agent_servers/src/claude.rs
+++ b/crates/agent_servers/src/claude.rs
@@ -43,6 +43,10 @@ use acp_thread::{AcpThread, AgentConnection, AuthRequired, LoadError, MentionUri
 pub struct ClaudeCode;

 impl AgentServer for ClaudeCode {
+    fn telemetry_id(&self) -> &'static str {
+        "claude-code"
+    }
+
    fn name(&self) -> SharedString {
        "Claude Code".into()
    }
@@ -249,13 +253,19 @@ impl AgentConnection for ClaudeAgentConnection {
            });

            let action_log = cx.new(|_| ActionLog::new(project.clone()))?;
-            let thread = cx.new(|_cx| {
+            let thread = cx.new(|cx| {
                AcpThread::new(
                    "Claude Code",
                    self.clone(),
                    project,
                    action_log,
                    session_id.clone(),
+                    watch::Receiver::constant(acp::PromptCapabilities {
+                        image: true,
+                        audio: false,
+                        embedded_context: true,
+                    }),
+                    cx,
                )
            })?;

@@ -319,14 +329,6 @@ impl AgentConnection for ClaudeAgentConnection {
        cx.foreground_executor().spawn(async move { end_rx.await? })
    }

-    fn prompt_capabilities(&self) -> acp::PromptCapabilities {
-        acp::PromptCapabilities {
-            image: true,
-            audio: false,
-            embedded_context: true,
-        }
-    }
-
    fn cancel(&self, session_id: &acp::SessionId, _cx: &mut App) {
        let sessions = self.sessions.borrow();
        let Some(session) = sessions.get(session_id) else {
--- a/crates/agent_servers/src/custom.rs
+++ b/crates/agent_servers/src/custom.rs
@@ -22,6 +22,10 @@ impl CustomAgentServer {
 }

 impl crate::AgentServer for CustomAgentServer {
+    fn telemetry_id(&self) -> &'static str {
+        "custom"
+    }
+
    fn name(&self) -> SharedString {
        self.name.clone()
    }
--- a/crates/agent_servers/src/gemini.rs
+++ b/crates/agent_servers/src/gemini.rs
@@ -17,6 +17,10 @@ pub struct Gemini;
 const ACP_ARG: &str = "--experimental-acp";

 impl AgentServer for Gemini {
+    fn telemetry_id(&self) -> &'static str {
+        "gemini-cli"
+    }
+
    fn name(&self) -> SharedString {
        "Gemini CLI".into()
    }
@@ -53,7 +57,7 @@ impl AgentServer for Gemini {
                return Err(LoadError::NotInstalled {
                    error_message: "Failed to find Gemini CLI binary".into(),
                    install_message: "Install Gemini CLI".into(),
-                    install_command: "npm install -g @google/gemini-cli@preview".into()
+                    install_command: Self::install_command().into(),
                }.into());
            };

@@ -88,7 +92,7 @@ impl AgentServer for Gemini {
                            current_version
                        ).into(),
                        upgrade_message: "Upgrade Gemini CLI to latest".into(),
-                        upgrade_command: "npm install -g @google/gemini-cli@preview".into(),
+                        upgrade_command: Self::upgrade_command().into(),
                    }.into())
                }
            }
@@ -101,6 +105,20 @@ impl AgentServer for Gemini {
    }
 }

+impl Gemini {
+    pub fn binary_name() -> &'static str {
+        "gemini"
+    }
+
+    pub fn install_command() -> &'static str {
+        "npm install -g @google/gemini-cli@preview"
+    }
+
+    pub fn upgrade_command() -> &'static str {
+        "npm install -g @google/gemini-cli@preview"
+    }
+}
+
 #[cfg(test)]
 pub(crate) mod tests {
    use super::*;
--- a/crates/agent_ui/src/acp/message_editor.rs
+++ b/crates/agent_ui/src/acp/message_editor.rs
@@ -74,6 +74,7 @@ pub enum MessageEditorEvent {
    Send,
    Cancel,
    Focus,
+    LostFocus,
 }

 impl EventEmitter<MessageEditorEvent> for MessageEditor {}
@@ -131,10 +132,14 @@ impl MessageEditor {
            editor
        });

-        cx.on_focus(&editor.focus_handle(cx), window, |_, _, cx| {
+        cx.on_focus_in(&editor.focus_handle(cx), window, |_, _, cx| {
            cx.emit(MessageEditorEvent::Focus)
        })
        .detach();
+        cx.on_focus_out(&editor.focus_handle(cx), window, |_, _, _, cx| {
+            cx.emit(MessageEditorEvent::LostFocus)
+        })
+        .detach();

        let mut subscriptions = Vec::new();
        subscriptions.push(cx.subscribe_in(&editor, window, {
@@ -368,7 +373,7 @@ impl MessageEditor {

        if Img::extensions().contains(&extension) && !extension.contains("svg") {
            if !self.prompt_capabilities.get().image {
-                return Task::ready(Err(anyhow!("This agent does not support images yet")));
+                return Task::ready(Err(anyhow!("This model does not support images yet")));
            }
            let task = self
                .project
@@ -1169,17 +1174,16 @@ impl MessageEditor {
        })
    }

+    pub fn text(&self, cx: &App) -> String {
+        self.editor.read(cx).text(cx)
+    }
+
    #[cfg(test)]
    pub fn set_text(&mut self, text: &str, window: &mut Window, cx: &mut Context<Self>) {
        self.editor.update(cx, |editor, cx| {
            editor.set_text(text, window, cx);
        });
    }
-
-    #[cfg(test)]
-    pub fn text(&self, cx: &App) -> String {
-        self.editor.read(cx).text(cx)
-    }
 }

 fn render_directory_contents(entries: Vec<(Arc<Path>, PathBuf, String)>) -> String {
--- a/crates/agent_ui/src/acp/thread_history.rs
+++ b/crates/agent_ui/src/acp/thread_history.rs
@@ -462,7 +462,7 @@ impl AcpThreadHistory {

                        cx.notify();
                    }))
-                    .end_slot::<IconButton>(if hovered || selected {
+                    .end_slot::<IconButton>(if hovered {
                        Some(
                            IconButton::new("delete", IconName::Trash)
                                .shape(IconButtonShape::Square)
--- a/crates/agent_ui/src/acp/thread_view.rs
+++ b/crates/agent_ui/src/acp/thread_view.rs
--- a/crates/agent_ui/src/agent_configuration.rs
+++ b/crates/agent_ui/src/agent_configuration.rs
@@ -5,6 +5,7 @@ mod tool_picker;

 use std::{sync::Arc, time::Duration};

+use agent_servers::{AgentServerCommand, AllAgentServersSettings, Gemini};
 use agent_settings::AgentSettings;
 use assistant_tool::{ToolSource, ToolWorkingSet};
 use cloud_llm_client::Plan;
@@ -15,7 +16,7 @@ use extension_host::ExtensionStore;
 use fs::Fs;
 use gpui::{
    Action, Animation, AnimationExt as _, AnyView, App, Corner, Entity, EventEmitter, FocusHandle,
-    Focusable, ScrollHandle, Subscription, Task, Transformation, WeakEntity, percentage,
+    Focusable, Hsla, ScrollHandle, Subscription, Task, Transformation, WeakEntity, percentage,
 };
 use language::LanguageRegistry;
 use language_model::{
@@ -23,10 +24,11 @@ use language_model::{
 };
 use notifications::status_toast::{StatusToast, ToastIcon};
 use project::{
+    Project,
    context_server_store::{ContextServerConfiguration, ContextServerStatus, ContextServerStore},
    project_settings::{ContextServerSettings, ProjectSettings},
 };
-use settings::{Settings, update_settings_file};
+use settings::{Settings, SettingsStore, update_settings_file};
 use ui::{
    Chip, ContextMenu, Disclosure, Divider, DividerColor, ElevationIndex, Indicator, PopoverMenu,
    Scrollbar, ScrollbarState, Switch, SwitchColor, SwitchField, Tooltip, prelude::*,
@@ -39,7 +41,7 @@ pub(crate) use configure_context_server_modal::ConfigureContextServerModal;
 pub(crate) use manage_profiles_modal::ManageProfilesModal;

 use crate::{
-    AddContextServer,
+    AddContextServer, ExternalAgent, NewExternalAgentThread,
    agent_configuration::add_llm_provider_modal::{AddLlmProviderModal, LlmCompatibleProvider},
 };

@@ -47,6 +49,7 @@ pub struct AgentConfiguration {
    fs: Arc<dyn Fs>,
    language_registry: Arc<LanguageRegistry>,
    workspace: WeakEntity<Workspace>,
+    project: WeakEntity<Project>,
    focus_handle: FocusHandle,
    configuration_views_by_provider: HashMap<LanguageModelProviderId, AnyView>,
    context_server_store: Entity<ContextServerStore>,
@@ -56,6 +59,8 @@ pub struct AgentConfiguration {
    _registry_subscription: Subscription,
    scroll_handle: ScrollHandle,
    scrollbar_state: ScrollbarState,
+    gemini_is_installed: bool,
+    _check_for_gemini: Task<()>,
 }

 impl AgentConfiguration {
@@ -65,6 +70,7 @@ impl AgentConfiguration {
        tools: Entity<ToolWorkingSet>,
        language_registry: Arc<LanguageRegistry>,
        workspace: WeakEntity<Workspace>,
+        project: WeakEntity<Project>,
        window: &mut Window,
        cx: &mut Context<Self>,
    ) -> Self {
@@ -89,6 +95,11 @@ impl AgentConfiguration {

        cx.subscribe(&context_server_store, |_, _, _, cx| cx.notify())
            .detach();
+        cx.observe_global_in::<SettingsStore>(window, |this, _, cx| {
+            this.check_for_gemini(cx);
+            cx.notify();
+        })
+        .detach();

        let scroll_handle = ScrollHandle::new();
        let scrollbar_state = ScrollbarState::new(scroll_handle.clone());
@@ -97,6 +108,7 @@ impl AgentConfiguration {
            fs,
            language_registry,
            workspace,
+            project,
            focus_handle,
            configuration_views_by_provider: HashMap::default(),
            context_server_store,
@@ -106,8 +118,11 @@ impl AgentConfiguration {
            _registry_subscription: registry_subscription,
            scroll_handle,
            scrollbar_state,
+            gemini_is_installed: false,
+            _check_for_gemini: Task::ready(()),
        };
        this.build_provider_configuration_views(window, cx);
+        this.check_for_gemini(cx);
        this
    }

@@ -137,6 +152,34 @@ impl AgentConfiguration {
        self.configuration_views_by_provider
            .insert(provider.id(), configuration_view);
    }
+
+    fn check_for_gemini(&mut self, cx: &mut Context<Self>) {
+        let project = self.project.clone();
+        let settings = AllAgentServersSettings::get_global(cx).clone();
+        self._check_for_gemini = cx.spawn({
+            async move |this, cx| {
+                let Some(project) = project.upgrade() else {
+                    return;
+                };
+                let gemini_is_installed = AgentServerCommand::resolve(
+                    Gemini::binary_name(),
+                    &[],
+                    // TODO expose fallback path from the Gemini/CC types so we don't have to hardcode it again here
+                    None,
+                    settings.gemini,
+                    &project,
+                    cx,
+                )
+                .await
+                .is_some();
+                this.update(cx, |this, cx| {
+                    this.gemini_is_installed = gemini_is_installed;
+                    cx.notify();
+                })
+                .ok();
+            }
+        });
+    }
 }

 impl Focusable for AgentConfiguration {
@@ -211,7 +254,6 @@ impl AgentConfiguration {
                    .child(
                        h_flex()
                            .id(provider_id_string.clone())
-                            .cursor_pointer()
                            .px_2()
                            .py_0p5()
                            .w_full()
@@ -231,10 +273,7 @@ impl AgentConfiguration {
                                        h_flex()
                                            .w_full()
                                            .gap_1()
-                                            .child(
-                                                Label::new(provider_name.clone())
-                                                    .size(LabelSize::Large),
-                                            )
+                                            .child(Label::new(provider_name.clone()))
                                            .map(|this| {
                                                if is_zed_provider && is_signed_in {
                                                    this.child(
@@ -279,7 +318,7 @@ impl AgentConfiguration {
                                "Start New Thread",
                            )
                            .icon_position(IconPosition::Start)
-                            .icon(IconName::Plus)
+                            .icon(IconName::Thread)
                            .icon_size(IconSize::Small)
                            .icon_color(Color::Muted)
                            .label_size(LabelSize::Small)
@@ -378,7 +417,7 @@ impl AgentConfiguration {
                                    ),
                            )
                            .child(
-                                Label::new("Add at least one provider to use AI-powered features.")
+                                Label::new("Add at least one provider to use AI-powered features with Zed's native agent.")
                                    .color(Color::Muted),
                            ),
                    ),
@@ -519,6 +558,14 @@ impl AgentConfiguration {
        }
    }

+    fn card_item_bg_color(&self, cx: &mut Context<Self>) -> Hsla {
+        cx.theme().colors().background.opacity(0.25)
+    }
+
+    fn card_item_border_color(&self, cx: &mut Context<Self>) -> Hsla {
+        cx.theme().colors().border.opacity(0.6)
+    }
+
    fn render_context_servers_section(
        &mut self,
        window: &mut Window,
@@ -536,7 +583,12 @@ impl AgentConfiguration {
                v_flex()
                    .gap_0p5()
                    .child(Headline::new("Model Context Protocol (MCP) Servers"))
-                    .child(Label::new("Connect to context servers through the Model Context Protocol, either using Zed extensions or directly.").color(Color::Muted)),
+                    .child(
+                        Label::new(
+                            "All context servers connected through the Model Context Protocol.",
+                        )
+                        .color(Color::Muted),
+                    ),
            )
            .children(
                context_server_ids.into_iter().map(|context_server_id| {
@@ -546,7 +598,7 @@ impl AgentConfiguration {
            .child(
                h_flex()
                    .justify_between()
-                    .gap_2()
+                    .gap_1p5()
                    .child(
                        h_flex().w_full().child(
                            Button::new("add-context-server", "Add Custom Server")
@@ -637,8 +689,6 @@ impl AgentConfiguration {
            .map_or([].as_slice(), |tools| tools.as_slice());
        let tool_count = tools.len();

-        let border_color = cx.theme().colors().border.opacity(0.6);
-
        let (source_icon, source_tooltip) = if is_from_extension {
            (
                IconName::ZedMcpExtension,
@@ -781,8 +831,8 @@ impl AgentConfiguration {
            .id(item_id.clone())
            .border_1()
            .rounded_md()
-            .border_color(border_color)
-            .bg(cx.theme().colors().background.opacity(0.2))
+            .border_color(self.card_item_border_color(cx))
+            .bg(self.card_item_bg_color(cx))
            .overflow_hidden()
            .child(
                h_flex()
@@ -790,7 +840,11 @@ impl AgentConfiguration {
                    .justify_between()
                    .when(
                        error.is_some() || are_tools_expanded && tool_count >= 1,
-                        |element| element.border_b_1().border_color(border_color),
+                        |element| {
+                            element
+                                .border_b_1()
+                                .border_color(self.card_item_border_color(cx))
+                        },
                    )
                    .child(
                        h_flex()
@@ -972,6 +1026,166 @@ impl AgentConfiguration {
                ))
            })
    }
+
+    fn render_agent_servers_section(&mut self, cx: &mut Context<Self>) -> impl IntoElement {
+        let settings = AllAgentServersSettings::get_global(cx).clone();
+        let user_defined_agents = settings
+            .custom
+            .iter()
+            .map(|(name, settings)| {
+                self.render_agent_server(
+                    IconName::Ai,
+                    name.clone(),
+                    ExternalAgent::Custom {
+                        name: name.clone(),
+                        settings: settings.clone(),
+                    },
+                    None,
+                    cx,
+                )
+                .into_any_element()
+            })
+            .collect::<Vec<_>>();
+
+        v_flex()
+            .border_b_1()
+            .border_color(cx.theme().colors().border)
+            .child(
+                v_flex()
+                    .p(DynamicSpacing::Base16.rems(cx))
+                    .pr(DynamicSpacing::Base20.rems(cx))
+                    .gap_2()
+                    .child(
+                        v_flex()
+                            .gap_0p5()
+                            .child(Headline::new("External Agents"))
+                            .child(
+                                Label::new(
+                                    "Use the full power of Zed's UI with your favorite agent, connected via the Agent Client Protocol.",
+                                )
+                                .color(Color::Muted),
+                            ),
+                    )
+                    .child(self.render_agent_server(
+                        IconName::AiGemini,
+                        "Gemini CLI",
+                        ExternalAgent::Gemini,
+                        (!self.gemini_is_installed).then_some(Gemini::install_command().into()),
+                        cx,
+                    ))
+                    // TODO add CC
+                    .children(user_defined_agents),
+            )
+    }
+
+    fn render_agent_server(
+        &self,
+        icon: IconName,
+        name: impl Into<SharedString>,
+        agent: ExternalAgent,
+        install_command: Option<SharedString>,
+        cx: &mut Context<Self>,
+    ) -> impl IntoElement {
+        let name = name.into();
+        h_flex()
+            .p_1()
+            .pl_2()
+            .gap_1p5()
+            .justify_between()
+            .border_1()
+            .rounded_md()
+            .border_color(self.card_item_border_color(cx))
+            .bg(self.card_item_bg_color(cx))
+            .overflow_hidden()
+            .child(
+                h_flex()
+                    .gap_1p5()
+                    .child(Icon::new(icon).size(IconSize::Small).color(Color::Muted))
+                    .child(Label::new(name.clone())),
+            )
+            .map(|this| {
+                if let Some(install_command) = install_command {
+                    this.child(
+                        Button::new(
+                            SharedString::from(format!("install_external_agent-{name}")),
+                            "Install Agent",
+                        )
+                        .label_size(LabelSize::Small)
+                        .icon(IconName::Plus)
+                        .icon_position(IconPosition::Start)
+                        .icon_size(IconSize::XSmall)
+                        .icon_color(Color::Muted)
+                        .tooltip(Tooltip::text(install_command.clone()))
+                        .on_click(cx.listener(
+                            move |this, _, window, cx| {
+                                let Some(project) = this.project.upgrade() else {
+                                    return;
+                                };
+                                let Some(workspace) = this.workspace.upgrade() else {
+                                    return;
+                                };
+                                let cwd = project.read(cx).first_project_directory(cx);
+                                let shell =
+                                    project.read(cx).terminal_settings(&cwd, cx).shell.clone();
+                                let spawn_in_terminal = task::SpawnInTerminal {
+                                    id: task::TaskId(install_command.to_string()),
+                                    full_label: install_command.to_string(),
+                                    label: install_command.to_string(),
+                                    command: Some(install_command.to_string()),
+                                    args: Vec::new(),
+                                    command_label: install_command.to_string(),
+                                    cwd,
+                                    env: Default::default(),
+                                    use_new_terminal: true,
+                                    allow_concurrent_runs: true,
+                                    reveal: Default::default(),
+                                    reveal_target: Default::default(),
+                                    hide: Default::default(),
+                                    shell,
+                                    show_summary: true,
+                                    show_command: true,
+                                    show_rerun: false,
+                                };
+                                let task = workspace.update(cx, |workspace, cx| {
+                                    workspace.spawn_in_terminal(spawn_in_terminal, window, cx)
+                                });
+                                cx.spawn(async move |this, cx| {
+                                    task.await;
+                                    this.update(cx, |this, cx| {
+                                        this.check_for_gemini(cx);
+                                    })
+                                    .ok();
+                                })
+                                .detach();
+                            },
+                        )),
+                    )
+                } else {
+                    this.child(
+                        h_flex().gap_1().child(
+                            Button::new(
+                                SharedString::from(format!("start_acp_thread-{name}")),
+                                "Start New Thread",
+                            )
+                            .label_size(LabelSize::Small)
+                            .icon(IconName::Thread)
+                            .icon_position(IconPosition::Start)
+                            .icon_size(IconSize::XSmall)
+                            .icon_color(Color::Muted)
+                            .on_click(move |_, window, cx| {
+                                window.dispatch_action(
+                                    NewExternalAgentThread {
+                                        agent: Some(agent.clone()),
+                                    }
+                                    .boxed_clone(),
+                                    cx,
+                                );
+                            }),
+                        ),
+                    )
+                }
+            })
+    }
 }

 impl Render for AgentConfiguration {
@@ -991,6 +1205,7 @@ impl Render for AgentConfiguration {
                    .size_full()
                    .overflow_y_scroll()
                    .child(self.render_general_settings_section(cx))
+                    .child(self.render_agent_servers_section(cx))
                    .child(self.render_context_servers_section(window, cx))
                    .child(self.render_provider_configuration_section(cx)),
            )
--- a/crates/agent_ui/src/agent_diff.rs
+++ b/crates/agent_ui/src/agent_diff.rs
@@ -1529,6 +1529,7 @@ impl AgentDiff {
            | AcpThreadEvent::TokenUsageUpdated
            | AcpThreadEvent::EntriesRemoved(_)
            | AcpThreadEvent::ToolAuthorizationRequired
+            | AcpThreadEvent::PromptCapabilitiesUpdated
            | AcpThreadEvent::Retry(_) => {}
        }
    }
--- a/crates/agent_ui/src/agent_panel.rs
+++ b/crates/agent_ui/src/agent_panel.rs
@@ -9,6 +9,7 @@ use agent_servers::AgentServerSettings;
 use agent2::{DbThreadMetadata, HistoryEntry};
 use db::kvp::{Dismissable, KEY_VALUE_STORE};
 use serde::{Deserialize, Serialize};
+use zed_actions::agent::ReauthenticateAgent;

 use crate::acp::{AcpThreadHistory, ThreadHistoryEvent};
 use crate::agent_diff::AgentDiffThread;
@@ -240,6 +241,7 @@ enum WhichFontSize {
    None,
 }

+// TODO unify this with ExternalAgent
 #[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize)]
 pub enum AgentType {
    #[default]
@@ -1024,6 +1026,8 @@ impl AgentPanel {
    }

    fn new_prompt_editor(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        telemetry::event!("Agent Thread Started", agent = "zed-text");
+
        let context = self
            .context_store
            .update(cx, |context_store, cx| context_store.create(cx));
@@ -1116,6 +1120,8 @@ impl AgentPanel {
                }
            };

+            telemetry::event!("Agent Thread Started", agent = ext_agent.name());
+
            let server = ext_agent.server(fs, history);

            this.update_in(cx, |this, window, cx| {
@@ -1473,6 +1479,7 @@ impl AgentPanel {
                tools,
                self.language_registry.clone(),
                self.workspace.clone(),
+                self.project.downgrade(),
                window,
                cx,
            )
@@ -2204,6 +2211,8 @@ impl AgentPanel {
            "Enable Full Screen"
        };

+        let selected_agent = self.selected_agent.clone();
+
        PopoverMenu::new("agent-options-menu")
            .trigger_with_tooltip(
                IconButton::new("agent-options-menu", IconName::Ellipsis)
@@ -2283,6 +2292,11 @@ impl AgentPanel {
                            .action("Settings", Box::new(OpenSettings))
                            .separator()
                            .action(full_screen_label, Box::new(ToggleZoom));
+
+                        if selected_agent == AgentType::Gemini {
+                            menu = menu.action("Reauthenticate", Box::new(ReauthenticateAgent))
+                        }
+
                        menu
                    }))
                }
@@ -2317,6 +2331,8 @@ impl AgentPanel {
            .menu({
                let menu = self.assistant_navigation_menu.clone();
                move |window, cx| {
+                    telemetry::event!("View Thread History Clicked");
+
                    if let Some(menu) = menu.as_ref() {
                        menu.update(cx, |_, cx| {
                            cx.defer_in(window, |menu, window, cx| {
@@ -2495,6 +2511,8 @@ impl AgentPanel {
                let workspace = self.workspace.clone();

                move |window, cx| {
+                    telemetry::event!("New Thread Clicked");
+
                    let active_thread = active_thread.clone();
                    Some(ContextMenu::build(window, cx, |mut menu, _window, cx| {
                        menu = menu
@@ -3751,6 +3769,11 @@ impl Render for AgentPanel {
                }
            }))
            .on_action(cx.listener(Self::toggle_burn_mode))
+            .on_action(cx.listener(|this, _: &ReauthenticateAgent, window, cx| {
+                if let Some(thread_view) = this.active_thread_view() {
+                    thread_view.update(cx, |thread_view, cx| thread_view.reauthenticate(window, cx))
+                }
+            }))
            .child(self.render_toolbar(window, cx))
            .children(self.render_onboarding(window, cx))
            .map(|parent| match &self.active_view {
--- a/crates/agent_ui/src/agent_ui.rs
+++ b/crates/agent_ui/src/agent_ui.rs
@@ -160,6 +160,7 @@ pub struct NewNativeAgentThreadFromSummary {
    from_session_id: agent_client_protocol::SessionId,
 }

+// TODO unify this with AgentType
 #[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 enum ExternalAgent {
@@ -174,6 +175,15 @@ enum ExternalAgent {
 }

 impl ExternalAgent {
+    fn name(&self) -> &'static str {
+        match self {
+            Self::NativeAgent => "zed",
+            Self::Gemini => "gemini-cli",
+            Self::ClaudeCode => "claude-code",
+            Self::Custom { .. } => "custom",
+        }
+    }
+
    pub fn server(
        &self,
        fs: Arc<dyn fs::Fs>,
--- a/crates/agent_ui/src/text_thread_editor.rs
+++ b/crates/agent_ui/src/text_thread_editor.rs
@@ -361,6 +361,7 @@ impl TextThreadEditor {
        if self.sending_disabled(cx) {
            return;
        }
+        telemetry::event!("Agent Message Sent", agent = "zed-text");
        self.send_to_model(window, cx);
    }

--- a/crates/ai_onboarding/src/ai_upsell_card.rs
+++ b/crates/ai_onboarding/src/ai_upsell_card.rs
@@ -12,11 +12,11 @@ use crate::{SignInStatus, YoungAccountBanner, plan_definitions::PlanDefinitions}

 #[derive(IntoElement, RegisterComponent)]
 pub struct AiUpsellCard {
-    pub sign_in_status: SignInStatus,
-    pub sign_in: Arc<dyn Fn(&mut Window, &mut App)>,
-    pub account_too_young: bool,
-    pub user_plan: Option<Plan>,
-    pub tab_index: Option<isize>,
+    sign_in_status: SignInStatus,
+    sign_in: Arc<dyn Fn(&mut Window, &mut App)>,
+    account_too_young: bool,
+    user_plan: Option<Plan>,
+    tab_index: Option<isize>,
 }

 impl AiUpsellCard {
@@ -43,6 +43,11 @@ impl AiUpsellCard {
            tab_index: None,
        }
    }
+
+    pub fn tab_index(mut self, tab_index: Option<isize>) -> Self {
+        self.tab_index = tab_index;
+        self
+    }
 }

 impl RenderOnce for AiUpsellCard {
--- a/crates/assistant_tools/src/fetch_tool.rs
+++ b/crates/assistant_tools/src/fetch_tool.rs
@@ -118,7 +118,7 @@ impl Tool for FetchTool {
    }

    fn needs_confirmation(&self, _: &serde_json::Value, _: &Entity<Project>, _: &App) -> bool {
-        false
+        true
    }

    fn may_perform_edits(&self) -> bool {
--- a/crates/assistant_tools/src/find_path_tool.rs
+++ b/crates/assistant_tools/src/find_path_tool.rs
@@ -435,8 +435,8 @@ mod test {
        assert_eq!(
            matches,
            &[
-                PathBuf::from("root/apple/banana/carrot"),
-                PathBuf::from("root/apple/bandana/carbonara")
+                PathBuf::from(path!("root/apple/banana/carrot")),
+                PathBuf::from(path!("root/apple/bandana/carbonara"))
            ]
        );

@@ -447,8 +447,8 @@ mod test {
        assert_eq!(
            matches,
            &[
-                PathBuf::from("root/apple/banana/carrot"),
-                PathBuf::from("root/apple/bandana/carbonara")
+                PathBuf::from(path!("root/apple/banana/carrot")),
+                PathBuf::from(path!("root/apple/bandana/carbonara"))
            ]
        );
    }
--- a/crates/assistant_tools/src/read_file_tool.rs
+++ b/crates/assistant_tools/src/read_file_tool.rs
@@ -68,7 +68,7 @@ impl Tool for ReadFileTool {
    }

    fn icon(&self) -> IconName {
-        IconName::ToolRead
+        IconName::ToolSearch
    }

    fn input_schema(&self, format: LanguageModelToolSchemaFormat) -> Result<serde_json::Value> {
--- a/crates/editor/src/element.rs
+++ b/crates/editor/src/element.rs
@@ -74,7 +74,7 @@ use std::{
    fmt::{self, Write},
    iter, mem,
    ops::{Deref, Range},
-    path::Path,
+    path::{self, Path},
    rc::Rc,
    sync::Arc,
    time::{Duration, Instant},
@@ -90,8 +90,8 @@ use unicode_segmentation::UnicodeSegmentation;
 use util::post_inc;
 use util::{RangeExt, ResultExt, debug_panic};
 use workspace::{
-    CollaboratorId, OpenInTerminal, OpenTerminal, RevealInProjectPanel, Workspace, item::Item,
-    notifications::NotifyTaskExt,
+    CollaboratorId, ItemSettings, OpenInTerminal, OpenTerminal, RevealInProjectPanel, Workspace,
+    item::Item, notifications::NotifyTaskExt,
 };

 /// Determines what kinds of highlights should be applied to a lines background.
@@ -3603,176 +3603,187 @@ impl EditorElement {
        let focus_handle = editor.focus_handle(cx);
        let colors = cx.theme().colors();

-        let header =
-            div()
-                .p_1()
-                .w_full()
-                .h(FILE_HEADER_HEIGHT as f32 * window.line_height())
-                .child(
-                    h_flex()
-                        .size_full()
-                        .gap_2()
-                        .flex_basis(Length::Definite(DefiniteLength::Fraction(0.667)))
-                        .pl_0p5()
-                        .pr_5()
-                        .rounded_sm()
-                        .when(is_sticky, |el| el.shadow_md())
-                        .border_1()
-                        .map(|div| {
-                            let border_color = if is_selected
-                                && is_folded
-                                && focus_handle.contains_focused(window, cx)
-                            {
-                                colors.border_focused
-                            } else {
-                                colors.border
-                            };
-                            div.border_color(border_color)
-                        })
-                        .bg(colors.editor_subheader_background)
-                        .hover(|style| style.bg(colors.element_hover))
-                        .map(|header| {
-                            let editor = self.editor.clone();
-                            let buffer_id = for_excerpt.buffer_id;
-                            let toggle_chevron_icon =
-                                FileIcons::get_chevron_icon(!is_folded, cx).map(Icon::from_path);
-                            header.child(
-                                div()
-                                    .hover(|style| style.bg(colors.element_selected))
-                                    .rounded_xs()
-                                    .child(
-                                        ButtonLike::new("toggle-buffer-fold")
-                                            .style(ui::ButtonStyle::Transparent)
-                                            .height(px(28.).into())
-                                            .width(px(28.))
-                                            .children(toggle_chevron_icon)
-                                            .tooltip({
-                                                let focus_handle = focus_handle.clone();
-                                                move |window, cx| {
-                                                    Tooltip::with_meta_in(
-                                                        "Toggle Excerpt Fold",
-                                                        Some(&ToggleFold),
-                                                        "Alt+click to toggle all",
-                                                        &focus_handle,
+        let header = div()
+            .p_1()
+            .w_full()
+            .h(FILE_HEADER_HEIGHT as f32 * window.line_height())
+            .child(
+                h_flex()
+                    .size_full()
+                    .gap_2()
+                    .flex_basis(Length::Definite(DefiniteLength::Fraction(0.667)))
+                    .pl_0p5()
+                    .pr_5()
+                    .rounded_sm()
+                    .when(is_sticky, |el| el.shadow_md())
+                    .border_1()
+                    .map(|div| {
+                        let border_color = if is_selected
+                            && is_folded
+                            && focus_handle.contains_focused(window, cx)
+                        {
+                            colors.border_focused
+                        } else {
+                            colors.border
+                        };
+                        div.border_color(border_color)
+                    })
+                    .bg(colors.editor_subheader_background)
+                    .hover(|style| style.bg(colors.element_hover))
+                    .map(|header| {
+                        let editor = self.editor.clone();
+                        let buffer_id = for_excerpt.buffer_id;
+                        let toggle_chevron_icon =
+                            FileIcons::get_chevron_icon(!is_folded, cx).map(Icon::from_path);
+                        header.child(
+                            div()
+                                .hover(|style| style.bg(colors.element_selected))
+                                .rounded_xs()
+                                .child(
+                                    ButtonLike::new("toggle-buffer-fold")
+                                        .style(ui::ButtonStyle::Transparent)
+                                        .height(px(28.).into())
+                                        .width(px(28.))
+                                        .children(toggle_chevron_icon)
+                                        .tooltip({
+                                            let focus_handle = focus_handle.clone();
+                                            move |window, cx| {
+                                                Tooltip::with_meta_in(
+                                                    "Toggle Excerpt Fold",
+                                                    Some(&ToggleFold),
+                                                    "Alt+click to toggle all",
+                                                    &focus_handle,
+                                                    window,
+                                                    cx,
+                                                )
+                                            }
+                                        })
+                                        .on_click(move |event, window, cx| {
+                                            if event.modifiers().alt {
+                                                // Alt+click toggles all buffers
+                                                editor.update(cx, |editor, cx| {
+                                                    editor.toggle_fold_all(
+                                                        &ToggleFoldAll,
                                                        window,
                                                        cx,
-                                                    )
-                                                }
-                                            })
-                                            .on_click(move |event, window, cx| {
-                                                if event.modifiers().alt {
-                                                    // Alt+click toggles all buffers
+                                                    );
+                                                });
+                                            } else {
+                                                // Regular click toggles single buffer
+                                                if is_folded {
                                                    editor.update(cx, |editor, cx| {
-                                                        editor.toggle_fold_all(
-                                                            &ToggleFoldAll,
-                                                            window,
-                                                            cx,
-                                                        );
+                                                        editor.unfold_buffer(buffer_id, cx);
                                                    });
                                                } else {
-                                                    // Regular click toggles single buffer
-                                                    if is_folded {
-                                                        editor.update(cx, |editor, cx| {
-                                                            editor.unfold_buffer(buffer_id, cx);
-                                                        });
-                                                    } else {
-                                                        editor.update(cx, |editor, cx| {
-                                                            editor.fold_buffer(buffer_id, cx);
-                                                        });
-                                                    }
+                                                    editor.update(cx, |editor, cx| {
+                                                        editor.fold_buffer(buffer_id, cx);
+                                                    });
                                                }
-                                            }),
-                                    ),
-                            )
-                        })
-                        .children(
-                            editor
-                                .addons
-                                .values()
-                                .filter_map(|addon| {
-                                    addon.render_buffer_header_controls(for_excerpt, window, cx)
-                                })
-                                .take(1),
+                                            }
+                                        }),
+                                ),
                        )
-                        .child(
-                            h_flex()
-                                .size(Pixels(12.0))
-                                .justify_center()
-                                .children(indicator),
-                        )
-                        .child(
-                            h_flex()
-                                .cursor_pointer()
-                                .id("path header block")
-                                .size_full()
-                                .justify_between()
-                                .overflow_hidden()
-                                .child(
-                                    h_flex()
-                                        .gap_2()
-                                        .child(
-                                            Label::new(
-                                                filename
-                                                    .map(SharedString::from)
-                                                    .unwrap_or_else(|| "untitled".into()),
-                                            )
-                                            .single_line()
-                                            .when_some(file_status, |el, status| {
-                                                el.color(if status.is_conflicted() {
-                                                    Color::Conflict
-                                                } else if status.is_modified() {
-                                                    Color::Modified
-                                                } else if status.is_deleted() {
-                                                    Color::Disabled
-                                                } else {
-                                                    Color::Created
-                                                })
-                                                .when(status.is_deleted(), |el| el.strikethrough())
-                                            }),
-                                        )
-                                        .when_some(parent_path, |then, path| {
-                                            then.child(div().child(path).text_color(
-                                                if file_status.is_some_and(FileStatus::is_deleted) {
-                                                    colors.text_disabled
-                                                } else {
-                                                    colors.text_muted
+                    })
+                    .children(
+                        editor
+                            .addons
+                            .values()
+                            .filter_map(|addon| {
+                                addon.render_buffer_header_controls(for_excerpt, window, cx)
+                            })
+                            .take(1),
+                    )
+                    .child(
+                        h_flex()
+                            .size(Pixels(12.0))
+                            .justify_center()
+                            .children(indicator),
+                    )
+                    .child(
+                        h_flex()
+                            .cursor_pointer()
+                            .id("path header block")
+                            .size_full()
+                            .justify_between()
+                            .overflow_hidden()
+                            .child(
+                                h_flex()
+                                    .gap_2()
+                                    .map(|path_header| {
+                                        let filename = filename
+                                            .map(SharedString::from)
+                                            .unwrap_or_else(|| "untitled".into());
+
+                                        path_header
+                                            .when(ItemSettings::get_global(cx).file_icons, |el| {
+                                                let path = path::Path::new(filename.as_str());
+                                                let icon = FileIcons::get_icon(path, cx)
+                                                    .unwrap_or_default();
+                                                let icon =
+                                                    Icon::from_path(icon).color(Color::Muted);
+                                                el.child(icon)
+                                            })
+                                            .child(Label::new(filename).single_line().when_some(
+                                                file_status,
+                                                |el, status| {
+                                                    el.color(if status.is_conflicted() {
+                                                        Color::Conflict
+                                                    } else if status.is_modified() {
+                                                        Color::Modified
+                                                    } else if status.is_deleted() {
+                                                        Color::Disabled
+                                                    } else {
+                                                        Color::Created
+                                                    })
+                                                    .when(status.is_deleted(), |el| {
+                                                        el.strikethrough()
+                                                    })
                                                },
                                            ))
-                                        }),
-                                )
-                                .when(
-                                    can_open_excerpts && is_selected && relative_path.is_some(),
-                                    |el| {
-                                        el.child(
-                                            h_flex()
-                                                .id("jump-to-file-button")
-                                                .gap_2p5()
-                                                .child(Label::new("Jump To File"))
-                                                .children(
-                                                    KeyBinding::for_action_in(
-                                                        &OpenExcerpts,
-                                                        &focus_handle,
-                                                        window,
-                                                        cx,
-                                                    )
-                                                    .map(|binding| binding.into_any_element()),
-                                                ),
-                                        )
-                                    },
-                                )
-                                .on_mouse_down(MouseButton::Left, |_, _, cx| cx.stop_propagation())
-                                .on_click(window.listener_for(&self.editor, {
-                                    move |editor, e: &ClickEvent, window, cx| {
-                                        editor.open_excerpts_common(
-                                            Some(jump_data.clone()),
-                                            e.modifiers().secondary(),
-                                            window,
-                                            cx,
-                                        );
-                                    }
-                                })),
-                        ),
-                );
+                                    })
+                                    .when_some(parent_path, |then, path| {
+                                        then.child(div().child(path).text_color(
+                                            if file_status.is_some_and(FileStatus::is_deleted) {
+                                                colors.text_disabled
+                                            } else {
+                                                colors.text_muted
+                                            },
+                                        ))
+                                    }),
+                            )
+                            .when(
+                                can_open_excerpts && is_selected && relative_path.is_some(),
+                                |el| {
+                                    el.child(
+                                        h_flex()
+                                            .id("jump-to-file-button")
+                                            .gap_2p5()
+                                            .child(Label::new("Jump To File"))
+                                            .children(
+                                                KeyBinding::for_action_in(
+                                                    &OpenExcerpts,
+                                                    &focus_handle,
+                                                    window,
+                                                    cx,
+                                                )
+                                                .map(|binding| binding.into_any_element()),
+                                            ),
+                                    )
+                                },
+                            )
+                            .on_mouse_down(MouseButton::Left, |_, _, cx| cx.stop_propagation())
+                            .on_click(window.listener_for(&self.editor, {
+                                move |editor, e: &ClickEvent, window, cx| {
+                                    editor.open_excerpts_common(
+                                        Some(jump_data.clone()),
+                                        e.modifiers().secondary(),
+                                        window,
+                                        cx,
+                                    );
+                                }
+                            })),
+                    ),
+            );

        let file = for_excerpt.buffer.file().cloned();
        let editor = self.editor.clone();
--- a/crates/file_finder/src/file_finder.rs
+++ b/crates/file_finder/src/file_finder.rs
@@ -1401,13 +1401,16 @@ impl PickerDelegate for FileFinderDelegate {
            #[cfg(windows)]
            let raw_query = raw_query.trim().to_owned().replace("/", "\\");
            #[cfg(not(windows))]
-            let raw_query = raw_query.trim().to_owned();
+            let raw_query = raw_query.trim();

-            let file_query_end = if path_position.path.to_str().unwrap_or(&raw_query) == raw_query {
+            let raw_query = raw_query.trim_end_matches(':').to_owned();
+            let path = path_position.path.to_str();
+            let path_trimmed = path.unwrap_or(&raw_query).trim_end_matches(':');
+            let file_query_end = if path_trimmed == raw_query {
                None
            } else {
                // Safe to unwrap as we won't get here when the unwrap in if fails
-                Some(path_position.path.to_str().unwrap().len())
+                Some(path.unwrap().len())
            };

            let query = FileSearchQuery {
--- a/crates/file_finder/src/file_finder_tests.rs
+++ b/crates/file_finder/src/file_finder_tests.rs
@@ -218,6 +218,7 @@ async fn test_matching_paths(cx: &mut TestAppContext) {
        " ndan ",
        " band ",
        "a bandana",
+        "bandana:",
    ] {
        picker
            .update_in(cx, |picker, window, cx| {
@@ -252,6 +253,53 @@ async fn test_matching_paths(cx: &mut TestAppContext) {
    }
 }

+#[gpui::test]
+async fn test_matching_paths_with_colon(cx: &mut TestAppContext) {
+    let app_state = init_test(cx);
+    app_state
+        .fs
+        .as_fake()
+        .insert_tree(
+            path!("/root"),
+            json!({
+                "a": {
+                    "foo:bar.rs": "",
+                    "foo.rs": "",
+                }
+            }),
+        )
+        .await;
+
+    let project = Project::test(app_state.fs.clone(), [path!("/root").as_ref()], cx).await;
+
+    let (picker, _, cx) = build_find_picker(project, cx);
+
+    // 'foo:' matches both files
+    cx.simulate_input("foo:");
+    picker.update(cx, |picker, _| {
+        assert_eq!(picker.delegate.matches.len(), 3);
+        assert_match_at_position(picker, 0, "foo.rs");
+        assert_match_at_position(picker, 1, "foo:bar.rs");
+    });
+
+    // 'foo:b' matches one of the files
+    cx.simulate_input("b");
+    picker.update(cx, |picker, _| {
+        assert_eq!(picker.delegate.matches.len(), 2);
+        assert_match_at_position(picker, 0, "foo:bar.rs");
+    });
+
+    cx.dispatch_action(editor::actions::Backspace);
+
+    // 'foo:1' matches both files, specifying which row to jump to
+    cx.simulate_input("1");
+    picker.update(cx, |picker, _| {
+        assert_eq!(picker.delegate.matches.len(), 3);
+        assert_match_at_position(picker, 0, "foo.rs");
+        assert_match_at_position(picker, 1, "foo:bar.rs");
+    });
+}
+
 #[gpui::test]
 async fn test_unicode_paths(cx: &mut TestAppContext) {
    let app_state = init_test(cx);
--- a/crates/gpui/src/platform/windows/dispatcher.rs
+++ b/crates/gpui/src/platform/windows/dispatcher.rs
@@ -9,10 +9,8 @@ use parking::Parker;
 use parking_lot::Mutex;
 use util::ResultExt;
 use windows::{
-    Foundation::TimeSpan,
    System::Threading::{
-        ThreadPool, ThreadPoolTimer, TimerElapsedHandler, WorkItemHandler, WorkItemOptions,
-        WorkItemPriority,
+        ThreadPool, ThreadPoolTimer, TimerElapsedHandler, WorkItemHandler, WorkItemPriority,
    },
    Win32::{
        Foundation::{LPARAM, WPARAM},
@@ -56,12 +54,7 @@ impl WindowsDispatcher {
                Ok(())
            })
        };
-        ThreadPool::RunWithPriorityAndOptionsAsync(
-            &handler,
-            WorkItemPriority::High,
-            WorkItemOptions::TimeSliced,
-        )
-        .log_err();
+        ThreadPool::RunWithPriorityAsync(&handler, WorkItemPriority::High).log_err();
    }

    fn dispatch_on_threadpool_after(&self, runnable: Runnable, duration: Duration) {
@@ -72,12 +65,7 @@ impl WindowsDispatcher {
                Ok(())
            })
        };
-        let delay = TimeSpan {
-            // A time period expressed in 100-nanosecond units.
-            // 10,000,000 ticks per second
-            Duration: (duration.as_nanos() / 100) as i64,
-        };
-        ThreadPoolTimer::CreateTimer(&handler, delay).log_err();
+        ThreadPoolTimer::CreateTimer(&handler, duration.into()).log_err();
    }
 }

--- a/crates/inspector_ui/Cargo.toml
+++ b/crates/inspector_ui/Cargo.toml
@@ -24,6 +24,7 @@ serde_json_lenient.workspace = true
 theme.workspace = true
 ui.workspace = true
 util.workspace = true
+util_macros.workspace = true
 workspace-hack.workspace = true
 workspace.workspace = true
 zed_actions.workspace = true
--- a/crates/inspector_ui/src/div_inspector.rs
+++ b/crates/inspector_ui/src/div_inspector.rs
@@ -25,7 +25,7 @@ use util::split_str_with_ranges;

 /// Path used for unsaved buffer that contains style json. To support the json language server, this
 /// matches the name used in the generated schemas.
-const ZED_INSPECTOR_STYLE_JSON: &str = "/zed-inspector-style.json";
+const ZED_INSPECTOR_STYLE_JSON: &str = util_macros::path!("/zed-inspector-style.json");

 pub(crate) struct DivInspector {
    state: State,
--- a/crates/languages/src/javascript/highlights.scm
+++ b/crates/languages/src/javascript/highlights.scm
@@ -231,6 +231,7 @@
  "implements"
  "interface"
  "keyof"
+  "module"
  "namespace"
  "private"
  "protected"
@@ -250,4 +251,4 @@
 (jsx_closing_element (["</" ">"]) @punctuation.bracket.jsx)
 (jsx_self_closing_element (["<" "/>"]) @punctuation.bracket.jsx)
 (jsx_attribute "=" @punctuation.delimiter.jsx)
-(jsx_text) @text.jsx
+(jsx_text) @text.jsx
--- a/crates/languages/src/javascript/injections.scm
+++ b/crates/languages/src/javascript/injections.scm
@@ -11,6 +11,21 @@
                              (#set! injection.language "css"))
 )

+(call_expression
+  function: (member_expression
+    object: (identifier) @_obj (#eq? @_obj "styled")
+    property: (property_identifier))
+  arguments: (template_string (string_fragment) @injection.content
+                              (#set! injection.language "css"))
+)
+
+(call_expression
+  function: (call_expression
+    function: (identifier) @_name (#eq? @_name "styled"))
+  arguments: (template_string (string_fragment) @injection.content
+                              (#set! injection.language "css"))
+)
+
 (call_expression
  function: (identifier) @_name (#eq? @_name "html")
  arguments: (template_string) @injection.content
--- a/crates/languages/src/rust/highlights.scm
+++ b/crates/languages/src/rust/highlights.scm
@@ -6,9 +6,6 @@
 (self) @variable.special
 (field_identifier) @property

-(shorthand_field_initializer
-  (identifier) @property)
-
 (trait_item name: (type_identifier) @type.interface)
 (impl_item trait: (type_identifier) @type.interface)
 (abstract_type trait: (type_identifier) @type.interface)
@@ -41,20 +38,11 @@
    (identifier) @function.special
    (scoped_identifier
      name: (identifier) @function.special)
-  ]
-  "!" @function.special)
+  ])

 (macro_definition
  name: (identifier) @function.special.definition)

-(mod_item
-  name: (identifier) @module)
-
-(visibility_modifier [
-  (crate) @keyword
-  (super) @keyword
-])
-
 ; Identifier conventions

 ; Assume uppercase names are types/enum-constructors
@@ -127,7 +115,9 @@
  "where"
  "while"
  "yield"
+  (crate)
  (mutable_specifier)
+  (super)
 ] @keyword

 [
@@ -199,7 +189,6 @@
 operator: "/" @operator

 (lifetime) @lifetime
-(lifetime (identifier) @lifetime)

 (parameter (identifier) @variable.parameter)

--- a/crates/languages/src/tsx/highlights.scm
+++ b/crates/languages/src/tsx/highlights.scm
@@ -237,6 +237,7 @@
  "implements"
  "interface"
  "keyof"
+  "module"
  "namespace"
  "private"
  "protected"
@@ -256,4 +257,4 @@
 (jsx_closing_element (["</" ">"]) @punctuation.bracket.jsx)
 (jsx_self_closing_element (["<" "/>"]) @punctuation.bracket.jsx)
 (jsx_attribute "=" @punctuation.delimiter.jsx)
-(jsx_text) @text.jsx
+(jsx_text) @text.jsx
--- a/crates/languages/src/tsx/injections.scm
+++ b/crates/languages/src/tsx/injections.scm
@@ -11,6 +11,21 @@
                              (#set! injection.language "css"))
 )

+(call_expression
+  function: (member_expression
+    object: (identifier) @_obj (#eq? @_obj "styled")
+    property: (property_identifier))
+  arguments: (template_string (string_fragment) @injection.content
+                              (#set! injection.language "css"))
+)
+
+(call_expression
+  function: (call_expression
+    function: (identifier) @_name (#eq? @_name "styled"))
+  arguments: (template_string (string_fragment) @injection.content
+                              (#set! injection.language "css"))
+)
+
 (call_expression
  function: (identifier) @_name (#eq? @_name "html")
  arguments: (template_string (string_fragment) @injection.content
--- a/crates/languages/src/typescript/highlights.scm
+++ b/crates/languages/src/typescript/highlights.scm
@@ -248,6 +248,7 @@
  "is"
  "keyof"
  "let"
+  "module"
  "namespace"
  "new"
  "of"
@@ -272,4 +273,4 @@
  "while"
  "with"
  "yield"
-] @keyword
+] @keyword
--- a/crates/languages/src/typescript/injections.scm
+++ b/crates/languages/src/typescript/injections.scm
@@ -15,6 +15,21 @@
                              (#set! injection.language "css"))
 )

+(call_expression
+  function: (member_expression
+    object: (identifier) @_obj (#eq? @_obj "styled")
+    property: (property_identifier))
+  arguments: (template_string (string_fragment) @injection.content
+                              (#set! injection.language "css"))
+)
+
+(call_expression
+  function: (call_expression
+    function: (identifier) @_name (#eq? @_name "styled"))
+  arguments: (template_string (string_fragment) @injection.content
+                              (#set! injection.language "css"))
+)
+
 (call_expression
  function: (identifier) @_name (#eq? @_name "html")
  arguments: (template_string) @injection.content
--- a/crates/lsp/src/capabilities.rs
+++ b/crates/lsp/src/capabilities.rs
@@ -1,98 +0,0 @@
-use lsp_types::{
-    ServerCapabilities, TextDocumentSyncCapability, TextDocumentSyncKind,
-    TextDocumentSyncSaveOptions,
-};
-
-use super::DynamicCapabilities;
-
-pub mod cap {
-    pub struct DidChangeTextDocument;
-    pub struct DidSaveTextDocument;
-}
-
-pub trait EffectiveCapability {
-    type Value;
-    fn compute(static_caps: &ServerCapabilities, dynamic_caps: &DynamicCapabilities)
-    -> Self::Value;
-}
-
-impl EffectiveCapability for cap::DidChangeTextDocument {
-    type Value = Option<TextDocumentSyncKind>;
-
-    fn compute(
-        static_caps: &ServerCapabilities,
-        dynamic_caps: &DynamicCapabilities,
-    ) -> Self::Value {
-        dynamic_caps
-            .text_document_sync_did_change
-            .as_ref()
-            .and_then(|id_to_sync_kind_map| {
-                if id_to_sync_kind_map.is_empty() {
-                    return None;
-                }
-                let mut has_incremental = false;
-                for data in id_to_sync_kind_map.values() {
-                    let sync_kind = match data.sync_kind {
-                        0 => Some(TextDocumentSyncKind::NONE),
-                        1 => Some(TextDocumentSyncKind::FULL),
-                        2 => Some(TextDocumentSyncKind::INCREMENTAL),
-                        _ => None,
-                    };
-                    if sync_kind == Some(TextDocumentSyncKind::FULL) {
-                        return Some(TextDocumentSyncKind::FULL);
-                    }
-                    if sync_kind == Some(TextDocumentSyncKind::INCREMENTAL) {
-                        has_incremental = true;
-                    }
-                }
-                if has_incremental {
-                    Some(TextDocumentSyncKind::INCREMENTAL)
-                } else {
-                    None
-                }
-            })
-            .or_else(|| {
-                static_caps
-                    .text_document_sync
-                    .as_ref()
-                    .and_then(|sync| match sync {
-                        TextDocumentSyncCapability::Kind(kind) => Some(*kind),
-                        TextDocumentSyncCapability::Options(opts) => opts.change,
-                    })
-            })
-    }
-}
-
-impl EffectiveCapability for cap::DidSaveTextDocument {
-    type Value = Option<bool>;
-
-    fn compute(
-        static_caps: &ServerCapabilities,
-        dynamic_caps: &DynamicCapabilities,
-    ) -> Self::Value {
-        dynamic_caps
-            .text_document_sync_did_save
-            .as_ref()
-            .and_then(|id_to_save_options_map| {
-                if id_to_save_options_map.is_empty() {
-                    None
-                } else {
-                    Some(
-                        id_to_save_options_map
-                            .values()
-                            .any(|data| data.include_text.unwrap_or(false)),
-                    )
-                }
-            })
-            .or_else(|| match static_caps.text_document_sync.as_ref()? {
-                TextDocumentSyncCapability::Options(opts) => match opts.save.as_ref()? {
-                    TextDocumentSyncSaveOptions::Supported(true) => Some(false),
-                    TextDocumentSyncSaveOptions::Supported(false) => None,
-                    TextDocumentSyncSaveOptions::SaveOptions(save_opts) => {
-                        Some(save_opts.include_text.unwrap_or(false))
-                    }
-                },
-                TextDocumentSyncCapability::Kind(_) => None,
-            })
-    }
-}
--- a/crates/lsp/src/lsp.rs
+++ b/crates/lsp/src/lsp.rs
@@ -1,8 +1,5 @@
-mod capabilities;
 mod input_handler;

-pub use capabilities::{EffectiveCapability, cap};
-
 pub use lsp_types::request::*;
 pub use lsp_types::*;

@@ -89,8 +86,7 @@ pub struct LanguageServer {
    name: LanguageServerName,
    process_name: Arc<str>,
    binary: LanguageServerBinary,
-    static_capabilities: RwLock<ServerCapabilities>,
-    dynamic_capabilities: RwLock<DynamicCapabilities>,
+    capabilities: RwLock<ServerCapabilities>,
    /// Configuration sent to the server, stored for display in the language server logs
    /// buffer. This is represented as the message sent to the LSP in order to avoid cloning it (can
    /// be large in cases like sending schemas to the json server).
@@ -305,13 +301,6 @@ pub struct AdapterServerCapabilities {
    pub code_action_kinds: Option<Vec<CodeActionKind>>,
 }

-#[derive(Debug, Default, Clone)]
-pub struct DynamicCapabilities {
-    pub text_document_sync_did_change:
-        Option<HashMap<String, TextDocumentChangeRegistrationOptions>>,
-    pub text_document_sync_did_save: Option<HashMap<String, TextDocumentSaveRegistrationOptions>>,
-}
-
 impl LanguageServer {
    /// Starts a language server process.
    pub fn new(
@@ -495,8 +484,7 @@ impl LanguageServer {
                .map(|name| Arc::from(name.to_string_lossy()))
                .unwrap_or_default(),
            binary,
-            static_capabilities: Default::default(),
-            dynamic_capabilities: Default::default(),
+            capabilities: Default::default(),
            configuration,
            code_action_kinds,
            next_id: Default::default(),
@@ -910,7 +898,7 @@ impl LanguageServer {
            if let Some(info) = response.server_info {
                self.process_name = info.name.into();
            }
-            self.static_capabilities = RwLock::new(response.capabilities);
+            self.capabilities = RwLock::new(response.capabilities);
            self.configuration = configuration;

            self.notify::<notification::Initialized>(&InitializedParams {})?;
@@ -1142,18 +1130,7 @@ impl LanguageServer {

    /// Get the reported capabilities of the running language server.
    pub fn capabilities(&self) -> ServerCapabilities {
-        self.static_capabilities.read().clone()
-    }
-
-    pub fn update_dynamic_capabilities(&self, update: impl FnOnce(&mut DynamicCapabilities)) {
-        update(self.dynamic_capabilities.write().deref_mut());
-    }
-
-    /// Get effective capabilities by combining static and dynamic capabilities.
-    pub fn effective_capability<Cap: EffectiveCapability>(&self) -> Cap::Value {
-        let static_capabilities = self.capabilities();
-        let dynamic_capabilities = self.dynamic_capabilities.read().clone();
-        Cap::compute(&static_capabilities, &dynamic_capabilities)
+        self.capabilities.read().clone()
    }

    /// Get the reported capabilities of the running language server and
@@ -1166,7 +1143,7 @@ impl LanguageServer {
    }

    pub fn update_capabilities(&self, update: impl FnOnce(&mut ServerCapabilities)) {
-        update(self.static_capabilities.write().deref_mut());
+        update(self.capabilities.write().deref_mut());
    }

    pub fn configuration(&self) -> &Value {
--- a/crates/markdown/src/markdown.rs
+++ b/crates/markdown/src/markdown.rs
@@ -1085,10 +1085,10 @@ impl Element for MarkdownElement {
                                );
                                el.child(
                                    h_flex()
-                                        .w_5()
+                                        .w_4()
                                        .absolute()
-                                        .top_1()
-                                        .right_1()
+                                        .top_1p5()
+                                        .right_1p5()
                                        .justify_end()
                                        .child(codeblock),
                                )
@@ -1115,11 +1115,12 @@ impl Element for MarkdownElement {
                                    cx,
                                );
                                el.child(
-                                    div()
+                                    h_flex()
+                                        .w_4()
                                        .absolute()
                                        .top_0()
                                        .right_0()
-                                        .w_5()
+                                        .justify_end()
                                        .visible_on_hover("code_block")
                                        .child(codeblock),
                                )
--- a/crates/multi_buffer/src/multi_buffer.rs
+++ b/crates/multi_buffer/src/multi_buffer.rs
@@ -835,7 +835,7 @@ impl MultiBuffer {
                this.convert_edits_to_buffer_edits(edits, &snapshot, &original_indent_columns);
            drop(snapshot);

-            let mut buffer_ids = Vec::new();
+            let mut buffer_ids = Vec::with_capacity(buffer_edits.len());
            for (buffer_id, mut edits) in buffer_edits {
                buffer_ids.push(buffer_id);
                edits.sort_by_key(|edit| edit.range.start);
--- a/crates/onboarding/src/ai_setup_page.rs
+++ b/crates/onboarding/src/ai_setup_page.rs
@@ -283,17 +283,13 @@ pub(crate) fn render_ai_setup_page(
            v_flex()
                .mt_2()
                .gap_6()
-                .child({
-                    let mut ai_upsell_card =
-                        AiUpsellCard::new(client, &user_store, user_store.read(cx).plan(), cx);
-
-                    ai_upsell_card.tab_index = Some({
-                        tab_index += 1;
-                        tab_index - 1
-                    });
-
-                    ai_upsell_card
-                })
+                .child(
+                    AiUpsellCard::new(client, &user_store, user_store.read(cx).plan(), cx)
+                        .tab_index(Some({
+                            tab_index += 1;
+                            tab_index - 1
+                        })),
+                )
                .child(render_llm_provider_section(
                    &mut tab_index,
                    workspace,
--- a/crates/open_ai/src/open_ai.rs
+++ b/crates/open_ai/src/open_ai.rs
@@ -446,7 +446,6 @@ pub enum ResponseStreamResult {

 #[derive(Serialize, Deserialize, Debug)]
 pub struct ResponseStreamEvent {
-    pub model: String,
    pub choices: Vec<ChoiceDelta>,
    pub usage: Option<Usage>,
 }
--- a/crates/project/src/lsp_store.rs
+++ b/crates/project/src/lsp_store.rs
@@ -74,8 +74,9 @@ use lsp::{
    FileOperationPatternKind, FileOperationRegistrationOptions, FileRename, FileSystemWatcher,
    LSP_REQUEST_TIMEOUT, LanguageServer, LanguageServerBinary, LanguageServerBinaryOptions,
    LanguageServerId, LanguageServerName, LanguageServerSelector, LspRequestFuture,
-    MessageActionItem, MessageType, OneOf, RenameFilesParams, SymbolKind, TextEdit,
-    WillRenameFiles, WorkDoneProgressCancelParams, WorkspaceFolder, notification::DidRenameFiles,
+    MessageActionItem, MessageType, OneOf, RenameFilesParams, SymbolKind,
+    TextDocumentSyncSaveOptions, TextEdit, WillRenameFiles, WorkDoneProgressCancelParams,
+    WorkspaceFolder, notification::DidRenameFiles,
 };
 use node_runtime::read_package_installed_version;
 use parking_lot::Mutex;
@@ -7207,8 +7208,14 @@ impl LspStore {
                    .collect()
            };

-            let document_sync_kind =
-                language_server.effective_capability::<lsp::cap::DidChangeTextDocument>();
+            let document_sync_kind = language_server
+                .capabilities()
+                .text_document_sync
+                .as_ref()
+                .and_then(|sync| match sync {
+                    lsp::TextDocumentSyncCapability::Kind(kind) => Some(*kind),
+                    lsp::TextDocumentSyncCapability::Options(options) => options.change,
+                });

            let content_changes: Vec<_> = match document_sync_kind {
                Some(lsp::TextDocumentSyncKind::FULL) => {
@@ -7269,9 +7276,7 @@ impl LspStore {
        let local = self.as_local()?;

        for server in local.language_servers_for_worktree(worktree_id) {
-            if let Some(include_text) =
-                server.effective_capability::<lsp::cap::DidSaveTextDocument>()
-            {
+            if let Some(include_text) = include_text(server.as_ref()) {
                let text = if include_text {
                    Some(buffer.read(cx).text())
                } else {
@@ -11832,27 +11837,47 @@ impl LspStore {
                    }
                }
                "textDocument/didChange" => {
-                    if let Some(options) = reg.register_options {
-                        let options: lsp::TextDocumentChangeRegistrationOptions =
-                            serde_json::from_value(options)?;
-                        server.update_dynamic_capabilities(|dyn_caps| {
-                            let map = dyn_caps
-                                .text_document_sync_did_change
-                                .get_or_insert_with(HashMap::default);
-                            map.insert(reg.id, options);
+                    if let Some(sync_kind) = reg
+                        .register_options
+                        .and_then(|opts| opts.get("syncKind").cloned())
+                        .map(serde_json::from_value::<lsp::TextDocumentSyncKind>)
+                        .transpose()?
+                    {
+                        server.update_capabilities(|capabilities| {
+                            let mut sync_options =
+                                Self::take_text_document_sync_options(capabilities);
+                            sync_options.change = Some(sync_kind);
+                            capabilities.text_document_sync =
+                                Some(lsp::TextDocumentSyncCapability::Options(sync_options));
                        });
                        notify_server_capabilities_updated(&server, cx);
                    }
                }
                "textDocument/didSave" => {
-                    if let Some(options) = reg.register_options {
-                        let options: lsp::TextDocumentSaveRegistrationOptions =
-                            serde_json::from_value(options)?;
-                        server.update_dynamic_capabilities(|dyn_caps| {
-                            let map = dyn_caps
-                                .text_document_sync_did_save
-                                .get_or_insert_with(HashMap::default);
-                            map.insert(reg.id, options);
+                    if let Some(include_text) = reg
+                        .register_options
+                        .map(|opts| {
+                            let transpose = opts
+                                .get("includeText")
+                                .cloned()
+                                .map(serde_json::from_value::<Option<bool>>)
+                                .transpose();
+                            match transpose {
+                                Ok(value) => Ok(value.flatten()),
+                                Err(e) => Err(e),
+                            }
+                        })
+                        .transpose()?
+                    {
+                        server.update_capabilities(|capabilities| {
+                            let mut sync_options =
+                                Self::take_text_document_sync_options(capabilities);
+                            sync_options.save =
+                                Some(TextDocumentSyncSaveOptions::SaveOptions(lsp::SaveOptions {
+                                    include_text,
+                                }));
+                            capabilities.text_document_sync =
+                                Some(lsp::TextDocumentSyncCapability::Options(sync_options));
                        });
                        notify_server_capabilities_updated(&server, cx);
                    }
@@ -12003,18 +12028,20 @@ impl LspStore {
                    notify_server_capabilities_updated(&server, cx);
                }
                "textDocument/didChange" => {
-                    server.update_dynamic_capabilities(|dyn_caps| {
-                        if let Some(map) = dyn_caps.text_document_sync_did_change.as_mut() {
-                            map.remove(&unreg.id);
-                        }
+                    server.update_capabilities(|capabilities| {
+                        let mut sync_options = Self::take_text_document_sync_options(capabilities);
+                        sync_options.change = None;
+                        capabilities.text_document_sync =
+                            Some(lsp::TextDocumentSyncCapability::Options(sync_options));
                    });
                    notify_server_capabilities_updated(&server, cx);
                }
                "textDocument/didSave" => {
-                    server.update_dynamic_capabilities(|dyn_caps| {
-                        if let Some(map) = dyn_caps.text_document_sync_did_save.as_mut() {
-                            map.remove(&unreg.id);
-                        }
+                    server.update_capabilities(|capabilities| {
+                        let mut sync_options = Self::take_text_document_sync_options(capabilities);
+                        sync_options.save = None;
+                        capabilities.text_document_sync =
+                            Some(lsp::TextDocumentSyncCapability::Options(sync_options));
                    });
                    notify_server_capabilities_updated(&server, cx);
                }
@@ -12125,6 +12152,20 @@ impl LspStore {
        Ok(())
    }

+    fn take_text_document_sync_options(
+        capabilities: &mut lsp::ServerCapabilities,
+    ) -> lsp::TextDocumentSyncOptions {
+        match capabilities.text_document_sync.take() {
+            Some(lsp::TextDocumentSyncCapability::Options(sync_options)) => sync_options,
+            Some(lsp::TextDocumentSyncCapability::Kind(sync_kind)) => {
+                let mut sync_options = lsp::TextDocumentSyncOptions::default();
+                sync_options.change = Some(sync_kind);
+                sync_options
+            }
+            None => lsp::TextDocumentSyncOptions::default(),
+        }
+    }
+
    #[cfg(any(test, feature = "test-support"))]
    pub fn forget_code_lens_task(&mut self, buffer_id: BufferId) -> Option<CodeLensTask> {
        let data = self.lsp_code_lens.get_mut(&buffer_id)?;
@@ -13224,6 +13265,23 @@ async fn populate_labels_for_symbols(
    }
 }

+fn include_text(server: &lsp::LanguageServer) -> Option<bool> {
+    match server.capabilities().text_document_sync.as_ref()? {
+        lsp::TextDocumentSyncCapability::Options(opts) => match opts.save.as_ref()? {
+            // Server wants didSave but didn't specify includeText.
+            lsp::TextDocumentSyncSaveOptions::Supported(true) => Some(false),
+            // Server doesn't want didSave at all.
+            lsp::TextDocumentSyncSaveOptions::Supported(false) => None,
+            // Server provided SaveOptions.
+            lsp::TextDocumentSyncSaveOptions::SaveOptions(save_options) => {
+                Some(save_options.include_text.unwrap_or(false))
+            }
+        },
+        // We do not have any save info. Kind affects didChange only.
+        lsp::TextDocumentSyncCapability::Kind(_) => None,
+    }
+}
+
 /// Completion items are displayed in a `UniformList`.
 /// Usually, those items are single-line strings, but in LSP responses,
 /// completion items `label`, `detail` and `label_details.description` may contain newlines or long spaces.
--- a/crates/watch/src/watch.rs
+++ b/crates/watch/src/watch.rs
@@ -162,6 +162,19 @@ impl<T> Receiver<T> {
            pending_waker_id: None,
        }
    }
+
+    /// Creates a new [`Receiver`] holding an initial value that will never change.
+    pub fn constant(value: T) -> Self {
+        let state = Arc::new(RwLock::new(State {
+            value,
+            wakers: BTreeMap::new(),
+            next_waker_id: WakerId::default(),
+            version: 0,
+            closed: false,
+        }));
+
+        Self { state, version: 0 }
+    }
 }

 impl<T: Clone> Receiver<T> {
--- a/crates/workspace/src/workspace.rs
+++ b/crates/workspace/src/workspace.rs
@@ -6622,15 +6622,29 @@ impl Render for Workspace {
                                    }
                                })
                                .children(self.zoomed.as_ref().and_then(|view| {
-                                    Some(div()
+                                    let zoomed_view = view.upgrade()?;
+                                    let div = div()
                                        .occlude()
                                        .absolute()
                                        .overflow_hidden()
                                        .border_color(colors.border)
                                        .bg(colors.background)
-                                        .child(view.upgrade()?)
+                                        .child(zoomed_view)
                                        .inset_0()
-                                        .shadow_lg())
+                                        .shadow_lg();
+
+                                    if !WorkspaceSettings::get_global(cx).zoomed_padding {
+                                       return Some(div);
+                                    }
+
+                                    Some(match self.zoomed_position {
+                                        Some(DockPosition::Left) => div.right_2().border_r_1(),
+                                        Some(DockPosition::Right) => div.left_2().border_l_1(),
+                                        Some(DockPosition::Bottom) => div.top_2().border_t_1(),
+                                        None => {
+                                            div.top_2().bottom_2().left_2().right_2().border_1()
+                                        }
+                                    })
                                }))
                                .children(self.render_notifications(window, cx)),
                        )
--- a/crates/workspace/src/workspace_settings.rs
+++ b/crates/workspace/src/workspace_settings.rs
@@ -29,6 +29,7 @@ pub struct WorkspaceSettings {
    pub on_last_window_closed: OnLastWindowClosed,
    pub resize_all_panels_in_dock: Vec<DockPosition>,
    pub close_on_file_delete: bool,
+    pub zoomed_padding: bool,
 }

 #[derive(Copy, Clone, Default, Serialize, Deserialize, JsonSchema)]
@@ -202,6 +203,12 @@ pub struct WorkspaceSettingsContent {
    ///
    /// Default: false
    pub close_on_file_delete: Option<bool>,
+    /// Whether to show padding for zoomed panels.
+    /// When enabled, zoomed bottom panels will have some top padding,
+    /// while zoomed left/right panels will have padding to the right/left (respectively).
+    ///
+    /// Default: true
+    pub zoomed_padding: Option<bool>,
 }

 #[derive(Deserialize)]
--- a/crates/zed/resources/info/SupportedPlatforms.plist
+++ b/crates/zed/resources/info/SupportedPlatforms.plist
@@ -0,0 +1,4 @@
+<key>CFBundleSupportedPlatforms</key>
+<array>
+    <string>MacOSX</string>
+</array>
--- a/crates/zed_actions/src/lib.rs
+++ b/crates/zed_actions/src/lib.rs
@@ -290,7 +290,9 @@ pub mod agent {
            Chat,
            /// Toggles the language model selector dropdown.
            #[action(deprecated_aliases = ["assistant::ToggleModelSelector", "assistant2::ToggleModelSelector"])]
-            ToggleModelSelector
+            ToggleModelSelector,
+            /// Triggers re-authentication on Gemini
+            ReauthenticateAgent
        ]
    );
 }
Author	SHA1	Message	Date
Conrad Irwin	5eb04c7b28	Cherry-pick bot2	2025-08-25 14:38:43 -06:00
Michael Sloan	0470baca50	open_ai: Remove `model` field from ResponseStreamEvent (#36902 ) Closes #36901 Release Notes: - Fixed use of Open WebUI as an LLM provider.	2025-08-25 19:50:08 +00:00
John Tur	4605b96630	Fix constant thread creation on Windows (#36779 ) See https://github.com/zed-industries/zed/issues/36057#issuecomment-3215808649 Fixes https://github.com/zed-industries/zed/issues/36057 Release Notes: - N/A	2025-08-25 12:45:28 -07:00
Danilo Leal	949398cb93	thread view: Fix some design papercuts (#36893 ) Release Notes: - N/A --------- Co-authored-by: Conrad Irwin <conrad.irwin@gmail.com> Co-authored-by: Ben Brandt <benjamin.j.brandt@gmail.com> Co-authored-by: Matt Miller <mattrx@gmail.com>	2025-08-25 21:07:30 +02:00
Cretezy	79e74b880b	workspace: Allow disabling of padding on zoomed panels (#31913 ) Screenshot: \| Before \| After \| \| -------\|------\| \| ![image](https://github.com/user-attachments/assets/629e7da2-6070-4abb-b469-3b0824524ca4) \| ![image](https://github.com/user-attachments/assets/99e54412-2e0b-4df9-9c40-a89b0411f6d8) \| \| ![image](https://github.com/user-attachments/assets/e99da846-f39b-47b5-808e-65c22a1af47b) \| ![image](https://github.com/user-attachments/assets/ccd4408f-8cce-44ec-a69a-81794125ec99) \| Release Notes: - Added `zoomed_padding` to allow disabling of padding around zoomed panels Co-authored-by: Mikayla Maki <mikayla@zed.dev>	2025-08-25 19:02:19 +00:00
Bennet Bo Fenner	59af2a7d1f	acp: Add telemetry (#36894 ) Release Notes: - N/A --------- Co-authored-by: Conrad Irwin <conrad.irwin@gmail.com>	2025-08-25 20:51:23 +02:00
Danilo Leal	c786c0150f	agent: Add section for agent servers in settings view (#35206 ) Release Notes: - N/A --------- Co-authored-by: Cole Miller <cole@zed.dev>	2025-08-25 14:45:24 -04:00
Cole Miller	5fd29d37a6	acp: Model-specific prompt capabilities for 1PA (#36879 ) Adds support for per-session prompt capabilities and capability changes on the Zed side (ACP itself still only has per-connection static capabilities for now), and uses it to reflect image support accurately in 1PA threads based on the currently-selected model. Release Notes: - N/A	2025-08-25 14:28:11 -04:00
Mikayla Maki	f1204dfc33	Revert "workspace: Disable padding on zoomed panels" (#36884 ) Reverts zed-industries/zed#36012 We thought we didn't need this UI, but it turns out it was load bearing :) Release Notes: - Restored the zoomed panel padding	2025-08-25 10:46:36 -07:00
Marshall Bowers	2e1ca47241	Make fields of `AiUpsellCard` private (#36888 ) This PR makes the fields of the `AiUpsellCard` private, for better encapsulation. Release Notes: - N/A	2025-08-25 17:21:20 +00:00
Finn Evers	5c346a4ccf	kotlin: Specify default language server (#36871 ) As of `db52fc3655`, the Kotlin extension has two language servers. However, following that change, no default language server for Kotlin was configured within this repo, which led to two language servers being activated for Kotlin by default. This PR makes `kotlin-language-server` the default language server for the extension. This also ensures that the [documentation within the repository](https://github.com/zed-extensions/kotlin?tab=readme-ov-file#kotlin-lsp) matches what is actually the case. Release Notes: - kotlin: Made `kotlin-language-server` the default language server.	2025-08-25 19:12:33 +02:00
Conrad Irwin	a102b08743	Require confirmation for fetch tool (#36881 ) Using prompt injection, the agent may be tricked into making a fetch request that includes unexpected data from the conversation in the URL. As agent conversations may contain sensitive information (like private code, or potentially even API keys), this seems bad. The easiest way to prevent this is to require the user to look at the URL before the model is allowed to fetch it. Thanks to @ant4g0nist for bringing this to our attention. Release Notes: - agent panel: The fetch tool now requires confirmation.	2025-08-25 16:03:07 +00:00
Marshall Bowers	2dc4f156b3	Revert "Capture `shorthand_field_initializer` and modules in Rust highlights (#35842 )" (#36880 ) This PR reverts https://github.com/zed-industries/zed/pull/35842, as it broke the syntax highlighting for `crate`: ### Before Revert <img width="367" height="70" alt="Screenshot 2025-08-25 at 11 29 50 AM" src="https://github.com/user-attachments/assets/ce9b8b59-4e89-43ed-84c7-95c0156b9168" /> ### After Revert <img width="353" height="69" alt="Screenshot 2025-08-25 at 11 32 17 AM" src="https://github.com/user-attachments/assets/b6df5a21-64db-4abf-aa76-f085236da0c4" /> This reverts commit `896a35f7be`. Release Notes: - Reverted https://github.com/zed-industries/zed/pull/35842.	2025-08-25 15:51:31 +00:00
Bennet Bo Fenner	557753d092	acp: Add Reauthenticate to dropdown (#36878 ) Release Notes: - N/A Co-authored-by: Conrad Irwin <conrad.irwin@gmail.com>	2025-08-25 15:46:07 +00:00
Conrad Irwin	65fb17e2c9	acp: Remember following state (#36793 ) A beta user reported that following was "lost" when asking for confirmation, I suspect they moved their cursor in the agent file while reviewing the change. Now we will resume following when the agent starts up again. Release Notes: - N/A	2025-08-25 09:34:30 -06:00
Smit Barmase	2fe3dbed31	project: Remove redundant Option from parse_register_capabilities (#36874 ) Release Notes: - N/A	2025-08-25 21:00:53 +05:30
Zach Riegel	fda5111dc0	Add CSS language injections for calls to `styled` (#33966 ) …emotion). Closes: https://github.com/zed-industries/zed/issues/17026 Release Notes: - Added CSS language injection support for styled-components and emotion in JavaScript, TypeScript, and TSX files.	2025-08-25 11:30:09 -04:00
Antonio Scandurra	69127d2bea	acp: Simplify control flow for native agent loop (#36868 ) Release Notes: - N/A Co-authored-by: Bennet Bo Fenner <bennetbo@gmx.de>	2025-08-25 13:38:19 +00:00
Bennet Bo Fenner	db949546cf	agent2: Less noisy logs (#36863 ) Release Notes: - N/A	2025-08-25 15:14:48 +02:00
Danilo Leal	2b5a302972	thread view: Prevent user message controls to be cut-off (#36865 ) In the thread view, when focusing on the user message, we display the editing control container absolutely-positioned in the top right. However, if there are no rules items and no restore checkpoint button _and_ it is the very first message, the editing controls container would be cut-off. This PR fixes that by giving it a bit more top padding. Release Notes: - N/A	2025-08-25 10:08:48 -03:00
Bennet Bo Fenner	4c0ad95acc	acp: Show retry button for errors (#36862 ) Release Notes: - N/A --------- Co-authored-by: Antonio Scandurra <me@as-cii.com>	2025-08-25 12:52:25 +00:00
Cole Miller	8c83281399	acp: Fix read_file tool flickering (#36854 ) We were rendering a Markdown link like `[Read file x.rs (lines Y-Z)](@selection)` while the tool ran, but then switching to just `x.rs` as soon as we got the file location from the tool call (due to an if/else in the UI code that applies to all tools). This caused a flicker, which is fixed by having `initial_title` return just the filename from the input as it arrives instead of a link that we're going to stop rendering almost immediately anyway. Release Notes: - N/A	2025-08-25 08:23:36 -04:00
Danilo Leal	dfc99de7b8	thread view: Add a few UI tweaks (#36845 ) Release Notes: - N/A	2025-08-25 08:18:23 -03:00
versecafe	fe5e81203f	Fix macOS arch reporting from `arch_ios` to `arch_arm` (#36217 ) ```xml <key>arch_kind</key> <string>arch_arm</string> ``` Closes #36037 Release Notes: - N/A	2025-08-25 13:55:56 +03:00
Hendrik Müller	c48197b280	util: Fix edge case when parsing paths (#36025 ) Searching for files broke a couple releases ago. It used to be possible to start typing part of a file name, then select a file (not confirm it yet) and then type in `:` and a line number to navigate directly to that line. The current behavior can be seen in the following screenshots. When the `:` is typed, the selection is lost, since no files match any more. <img width="552" height="370" alt="Screenshot From 2025-08-12 10-36-08" src="https://github.com/user-attachments/assets/e4b4b613-7f0c-40d7-94c9-04d8ab541656" /> <img width="553" height="124" alt="Screenshot From 2025-08-12 10-36-25" src="https://github.com/user-attachments/assets/843e9ecf-9e08-4fa6-9340-0388a957cbb2" /> <img width="549" height="370" alt="Screenshot From 2025-08-12 10-36-47" src="https://github.com/user-attachments/assets/4a1bbbd8-268a-4ea8-999f-6cef1eb34a45" /> --- With this PR, the previous behavior is restored and can be seen in these screenshots: <img width="552" height="370" alt="Screenshot From 2025-08-12 10-36-08" src="https://github.com/user-attachments/assets/466e1906-4735-47ae-a699-117bdd6490ca" /> <img width="549" height="370" alt="Screenshot From 2025-08-12 10-47-07" src="https://github.com/user-attachments/assets/17f3acda-662d-4962-9eb8-4b494f211d26" /> <img width="549" height="370" alt="Screenshot From 2025-08-12 10-47-21" src="https://github.com/user-attachments/assets/d98447fe-7377-4f4f-b3da-f690cd44c141" /> --- Release Notes: - Adjusted the file finder to show matching file paths when adding the `:row:column` to the query	2025-08-25 12:28:33 +03:00
Aleksei Gusev	11545c669e	Add file icons to multibuffer view (#36836 ) <img width="1988" height="1420" alt="multi-buffer-icons-git-diff" src="https://github.com/user-attachments/assets/48f9722f-ca09-4aa7-ad7a-0b7e85f440d9" /> Unfortunately, `cargo format` decided to reformat everything. Probably, because of hitting the right margin, no idea. The essence of this change is the following: ```rust .map(\|path_header\| { let filename = filename .map(SharedString::from) .unwrap_or_else(\|\| "untitled".into()); let path = path::Path::new(filename.as_str()); let icon = FileIcons::get_icon(path, cx).unwrap_or_default(); let icon = Icon::from_path(icon).color(Color::Muted); let label = Label::new(filename).single_line().when_some( file_status, \|el, status\| { el.color(if status.is_conflicted() { Color::Conflict } else if status.is_modified() { Color::Modified } else if status.is_deleted() { Color::Disabled } else { Color::Created }) .when(status.is_deleted(), \|el\| el.strikethrough()) }, ); path_header.child(icon).child(label) }) ``` Release Notes: - Added file icons to multi buffer view	2025-08-24 18:57:12 +02:00
Antonio Scandurra	a79aef7bdd	acp: Never build a request with a tool use without its corresponding result (#36847 ) Release Notes: - N/A	2025-08-24 16:30:34 +00:00
Bennet Bo Fenner	d8bffd7ef2	acp: Cancel editing when focus is lost and message was not changed (#36822 ) Release Notes: - N/A	2025-08-24 11:05:39 +00:00
Chuqiao Feng	54c7d9dc5f	Fix crash when opening inspector on Windows debug build (#36829 )	2025-08-24 11:01:42 +00:00
tidely	dd6fce6d4e	multi_buffer: Pre-allocate IDs when editing (#36819 ) Something I came across when looking at `edit_internal`. Potentially saves multiple re-allocations on an edit Release Notes: - N/A	2025-08-24 09:59:32 +03:00
versecafe	de5f87e8f2	languages: Add `module` to TS/JS keywords (#36830 ) <img width="376" height="166" alt="image" src="https://github.com/user-attachments/assets/ae32d74c-387b-4809-a0d6-cfa97888347d" /> Release Notes: - Improved syntax highlights for `module` keyword in TS/JS	2025-08-24 09:54:47 +03:00
Cole Miller	1b91f3de41	acp: Fix accidentally reverted thread view changes (#36825 ) Merge conflict resolution for #36741 accidentally reverted the changes in #36670 to allow expanding terminals individually and in #36675 to allow collapsing edit cards. This PR re-applies those changes, fixing the regression. Release Notes: - N/A	2025-08-24 00:02:23 +00:00