Fix duplicated tasks

fix file
add relativeFile
2025-06-11 14:22:44 -07:00 · 2025-06-11 14:07:01 -04:00 · 2025-06-11 13:57:33 -04:00 · 2025-06-11 13:30:06 -04:00 · 2025-06-11 12:38:12 +02:00 · 2025-06-11 18:37:34 +08:00
365 changed files with 15563 additions and 5999 deletions
--- a/.github/ISSUE_TEMPLATE/01_bug_ai.yml
+++ b/.github/ISSUE_TEMPLATE/01_bug_ai.yml
@@ -1,4 +1,4 @@
-name: Bug Report (AI Related)
+name: Bug Report (AI)
 description: Zed Agent Panel Bugs
 type: "Bug"
 labels: ["ai"]
@@ -19,15 +19,14 @@ body:
        2.
        3.

-        Actual Behavior:
-        Expected Behavior:
+        **Expected Behavior**:
+        **Actual Behavior**:

        ### Model Provider Details
        - Provider: (Anthropic via ZedPro, Anthropic via API key, Copilot Chat, Mistral, OpenAI, etc)
        - Model Name:
        - Mode: (Agent Panel, Inline Assistant, Terminal Assistant or Text Threads)
-        - MCP Servers in-use:
-        - Other Details:
+        - Other Details (MCPs, other settings, etc):
    validations:
      required: true

--- a/.github/ISSUE_TEMPLATE/02_bug_edit_predictions.yml
+++ b/.github/ISSUE_TEMPLATE/02_bug_edit_predictions.yml
@@ -1,36 +0,0 @@
-name: Bug Report (Edit Predictions)
-description: Zed Edit Predictions bugs
-type: "Bug"
-labels: ["ai", "inline completion", "zeta"]
-title: "Edit Predictions: <a short description of the Edit Prediction bug>"
-body:
-  - type: textarea
-    attributes:
-      label: Summary
-      description: Describe the bug with a one line summary, and provide detailed reproduction steps
-      value: |
-        <!-- Please insert a one line summary of the issue below -->
-        SUMMARY_SENTENCE_HERE
-
-        ### Description
-        <!--  Describe with sufficient detail to reproduce from a clean Zed install. -->
-        <!--  Please include the LLM provider and model name you are using -->
-        Steps to trigger the problem:
-        1.
-        2.
-        3.
-
-        Actual Behavior:
-        Expected Behavior:
-    validations:
-      required: true
-
-  - type: textarea
-    id: environment
-    attributes:
-      label: Zed Version and System Specs
-      description: 'Open Zed, and in the command palette select "zed: copy system specs into clipboard"'
-      placeholder: |
-        Output of "zed: copy system specs into clipboard"
-    validations:
-      required: true
--- a/.github/ISSUE_TEMPLATE/03_bug_git.yml
+++ b/.github/ISSUE_TEMPLATE/03_bug_git.yml
@@ -1,35 +0,0 @@
-name: Bug Report (Git)
-description: Zed Git-Related Bugs
-type: "Bug"
-labels: ["git"]
-title: "Git: <a short description of the Git bug>"
-body:
-  - type: textarea
-    attributes:
-      label: Summary
-      description: Describe the bug with a one line summary, and provide detailed reproduction steps
-      value: |
-        <!-- Please insert a one line summary of the issue below -->
-        SUMMARY_SENTENCE_HERE
-
-        ### Description
-        <!--  Describe with sufficient detail to reproduce from a clean Zed install. -->
-        Steps to trigger the problem:
-        1.
-        2.
-        3.
-
-        Actual Behavior:
-        Expected Behavior:
-
-    validations:
-      required: true
-  - type: textarea
-    id: environment
-    attributes:
-      label: Zed Version and System Specs
-      description: 'Open Zed, and in the command palette select "zed: copy system specs into clipboard"'
-      placeholder: |
-        Output of "zed: copy system specs into clipboard"
-    validations:
-      required: true
--- a/.github/ISSUE_TEMPLATE/04_bug_debugger.yml
+++ b/.github/ISSUE_TEMPLATE/04_bug_debugger.yml
@@ -19,8 +19,8 @@ body:
        2.
        3.

-        Actual Behavior:
-        Expected Behavior:
+        **Expected Behavior**:
+        **Actual Behavior**:

    validations:
      required: true
--- a/.github/ISSUE_TEMPLATE/10_bug_report.yml
+++ b/.github/ISSUE_TEMPLATE/10_bug_report.yml
@@ -18,14 +18,16 @@ body:
          - Issues with insufficient detail may be summarily closed.
        -->

+        DESCRIPTION_HERE
+
        Steps to reproduce:
        1.
        2.
        3.
        4.

-        Expected Behavior:
-        Actual Behavior:
+        **Expected Behavior**:
+        **Actual Behavior**:

        <!-- Before Submitting, did you:
          1. Include settings.json, keymap.json, .editorconfig if relevant?
--- a/.github/actions/build_docs/action.yml
+++ b/.github/actions/build_docs/action.yml
@@ -19,6 +19,12 @@ runs:
      shell: bash -euxo pipefail {0}
      run: ./script/linux

+    - name: Check for broken links
+      uses: lycheeverse/lychee-action@82202e5e9c2f4ef1a55a3d02563e1cb6041e5332 # v2.4.1
+      with:
+        args: --no-progress --exclude '^http' './docs/src/**/*'
+        fail: true
+
    - name: Build book
      shell: bash -euxo pipefail {0}
      run: |
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -183,6 +183,9 @@ jobs:
      - name: Check for todo! and FIXME comments
        run: script/check-todos

+      - name: Check modifier use in keymaps
+        run: script/check-keymaps
+
      - name: Run style checks
        uses: ./.github/actions/check_style

@@ -736,10 +739,69 @@ jobs:
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

+  freebsd:
+    timeout-minutes: 60
+    runs-on: github-8vcpu-ubuntu-2404
+    if: |
+      startsWith(github.ref, 'refs/tags/v')
+      || contains(github.event.pull_request.labels.*.name, 'run-bundling')
+    needs: [linux_tests]
+    name: Build Zed on FreeBSD
+    # env:
+    #   MYTOKEN : ${{ secrets.MYTOKEN }}
+    #   MYTOKEN2: "value2"
+    steps:
+      - uses: actions/checkout@v4
+      - name: Build FreeBSD remote-server
+        id: freebsd-build
+        uses: vmactions/freebsd-vm@c3ae29a132c8ef1924775414107a97cac042aad5 # v1.2.0
+        with:
+          # envs: "MYTOKEN MYTOKEN2"
+          usesh: true
+          release: 13.5
+          copyback: true
+          prepare: |
+            pkg install -y \
+              bash curl jq git \
+              rustup-init cmake-core llvm-devel-lite pkgconf protobuf # ibx11 alsa-lib rust-bindgen-cli
+          run: |
+            freebsd-version
+            sysctl hw.model
+            sysctl hw.ncpu
+            sysctl hw.physmem
+            sysctl hw.usermem
+            git config --global --add safe.directory /home/runner/work/zed/zed
+            rustup-init --profile minimal --default-toolchain none -y
+            . "$HOME/.cargo/env"
+            ./script/bundle-freebsd
+            mkdir -p out/
+            mv "target/zed-remote-server-freebsd-x86_64.gz" out/
+            rm -rf target/
+            cargo clean
+
+      - name: Upload Artifact to Workflow - zed-remote-server (run-bundling)
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
+        if: contains(github.event.pull_request.labels.*.name, 'run-bundling')
+        with:
+          name: zed-remote-server-${{ github.event.pull_request.head.sha || github.sha }}-x86_64-unknown-freebsd.gz
+          path: out/zed-remote-server-freebsd-x86_64.gz
+
+      - name: Upload Artifacts to release
+        uses: softprops/action-gh-release@de2c0eb89ae2a093876385947365aca7b0e5f844 # v1
+        if: ${{ !(contains(github.event.pull_request.labels.*.name, 'run-bundling')) }}
+        with:
+          draft: true
+          prerelease: ${{ env.RELEASE_CHANNEL == 'preview' }}
+          files: |
+            out/zed-remote-server-freebsd-x86_64.gz
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
  nix-build:
    name: Build with Nix
    uses: ./.github/workflows/nix.yml
    if: github.repository_owner == 'zed-industries' && contains(github.event.pull_request.labels.*.name, 'run-nix')
+    secrets: inherit
    with:
      flake-output: debug
      # excludes the final package to only cache dependencies
@@ -750,12 +812,12 @@ jobs:
    if: |
      startsWith(github.ref, 'refs/tags/v')
      && endsWith(github.ref, '-pre') && !endsWith(github.ref, '.0-pre')
-    needs: [bundle-mac, bundle-linux-x86_x64, bundle-linux-aarch64]
+    needs: [bundle-mac, bundle-linux-x86_x64, bundle-linux-aarch64, freebsd]
    runs-on:
      - self-hosted
      - bundle
    steps:
      - name: gh release
-        run: gh release edit $GITHUB_REF_NAME --draft=true
+        run: gh release edit $GITHUB_REF_NAME --draft=false
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
--- a/.github/workflows/eval.yml
+++ b/.github/workflows/eval.yml
@@ -30,6 +30,7 @@ jobs:
  noop:
    name: No-op
    runs-on: ubuntu-latest
+    if: github.repository_owner == 'zed-industries'
    steps:
      - name: No-op
        run: echo "Nothing to do"
--- a/.github/workflows/release_nightly.yml
+++ b/.github/workflows/release_nightly.yml
@@ -167,9 +167,54 @@ jobs:
      - name: Upload Zed Nightly
        run: script/upload-nightly linux-targz

+  freebsd:
+    timeout-minutes: 60
+    if: github.repository_owner == 'zed-industries'
+    runs-on: github-8vcpu-ubuntu-2404
+    needs: tests
+    env:
+      DIGITALOCEAN_SPACES_ACCESS_KEY: ${{ secrets.DIGITALOCEAN_SPACES_ACCESS_KEY }}
+      DIGITALOCEAN_SPACES_SECRET_KEY: ${{ secrets.DIGITALOCEAN_SPACES_SECRET_KEY }}
+    name: Build Zed on FreeBSD
+    # env:
+    #   MYTOKEN : ${{ secrets.MYTOKEN }}
+    #   MYTOKEN2: "value2"
+    steps:
+      - uses: actions/checkout@v4
+      - name: Build FreeBSD remote-server
+        id: freebsd-build
+        uses: vmactions/freebsd-vm@c3ae29a132c8ef1924775414107a97cac042aad5 # v1.2.0
+        with:
+          # envs: "MYTOKEN MYTOKEN2"
+          usesh: true
+          release: 13.5
+          copyback: true
+          prepare: |
+            pkg install -y \
+              bash curl jq git \
+              rustup-init cmake-core llvm-devel-lite pkgconf protobuf # ibx11 alsa-lib rust-bindgen-cli
+          run: |
+            freebsd-version
+            sysctl hw.model
+            sysctl hw.ncpu
+            sysctl hw.physmem
+            sysctl hw.usermem
+            git config --global --add safe.directory /home/runner/work/zed/zed
+            rustup-init --profile minimal --default-toolchain none -y
+            . "$HOME/.cargo/env"
+            ./script/bundle-freebsd
+            mkdir -p out/
+            mv "target/zed-remote-server-freebsd-x86_64.gz" out/
+            rm -rf target/
+            cargo clean
+
+      - name: Upload Zed Nightly
+        run: script/upload-nightly freebsd
+
  bundle-nix:
    name: Build and cache Nix package
    needs: tests
+    secrets: inherit
    uses: ./.github/workflows/nix.yml

  update-nightly-tag:
--- a/.github/workflows/unit_evals.yml
+++ b/.github/workflows/unit_evals.yml
@@ -19,6 +19,7 @@ env:

 jobs:
  unit_evals:
+    if: github.repository_owner == 'zed-industries'
    timeout-minutes: 60
    name: Run unit evals
    runs-on:
@@ -62,11 +63,11 @@ jobs:

      - name: Run unit evals
        shell: bash -euxo pipefail {0}
-        run: cargo nextest run --workspace --no-fail-fast --features eval --no-capture -E 'test(::eval_)' --test-threads 1
+        run: cargo nextest run --workspace --no-fail-fast --features eval --no-capture -E 'test(::eval_)'
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}

-      - name: Send the pull request link into the Slack channel
+      - name: Send failure message to Slack channel if needed
        if: ${{ failure() }}
        uses: slackapi/slack-github-action@b0fa283ad8fea605de13dc3f449259339835fc52
        with:
--- a/.zed/settings.json
+++ b/.zed/settings.json
@@ -47,6 +47,7 @@
  "remove_trailing_whitespace_on_save": true,
  "ensure_final_newline_on_save": true,
  "file_scan_exclusions": [
+    "crates/assistant_tools/src/evals/fixtures",
    "crates/eval/worktrees/",
    "crates/eval/repos/",
    "**/.git",
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -59,7 +59,7 @@ dependencies = [
 "assistant_slash_command",
 "assistant_slash_commands",
 "assistant_tool",
- "async-watch",
+ "assistant_tools",
 "audio",
 "buffer_diff",
 "chrono",
@@ -99,6 +99,7 @@ dependencies = [
 "paths",
 "picker",
 "postage",
+ "pretty_assertions",
 "project",
 "prompt_store",
 "proto",
@@ -130,6 +131,7 @@ dependencies = [
 "urlencoding",
 "util",
 "uuid",
+ "watch",
 "workspace",
 "workspace-hack",
 "zed_actions",
@@ -147,7 +149,6 @@ dependencies = [
 "deepseek",
 "fs",
 "gpui",
- "indexmap",
 "language_model",
 "lmstudio",
 "log",
@@ -631,7 +632,6 @@ name = "assistant_tool"
 version = "0.1.0"
 dependencies = [
 "anyhow",
- "async-watch",
 "buffer_diff",
 "clock",
 "collections",
@@ -653,6 +653,7 @@ dependencies = [
 "settings",
 "text",
 "util",
+ "watch",
 "workspace",
 "workspace-hack",
 "zlog",
@@ -665,7 +666,6 @@ dependencies = [
 "agent_settings",
 "anyhow",
 "assistant_tool",
- "async-watch",
 "buffer_diff",
 "chrono",
 "client",
@@ -705,6 +705,7 @@ dependencies = [
 "serde_json",
 "settings",
 "smallvec",
+ "smol",
 "streaming_diff",
 "strsim",
 "task",
@@ -716,6 +717,7 @@ dependencies = [
 "ui",
 "unindent",
 "util",
+ "watch",
 "web_search",
 "which 6.0.3",
 "workspace",
@@ -1074,15 +1076,6 @@ dependencies = [
 "tungstenite 0.26.2",
 ]

-[[package]]
-name = "async-watch"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a078faf4e27c0c6cc0efb20e5da59dcccc04968ebf2801d8e0b2195124cdcdb2"
-dependencies = [
- "event-listener 2.5.3",
-]
-
 [[package]]
 name = "async_zip"
 version = "0.0.17"
@@ -2987,7 +2980,6 @@ dependencies = [
 "anyhow",
 "assistant_context_editor",
 "assistant_slash_command",
- "assistant_tool",
 "async-stripe",
 "async-trait",
 "async-tungstenite",
@@ -3169,6 +3161,16 @@ dependencies = [
 "memchr",
 ]

+[[package]]
+name = "command-fds"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2ec1052629a80c28594777d1252efc8a6b005d13f9edfd8c3fc0f44d5b32489a"
+dependencies = [
+ "nix 0.30.1",
+ "thiserror 2.0.12",
+]
+
 [[package]]
 name = "command_palette"
 version = "0.1.0"
@@ -4025,6 +4027,7 @@ dependencies = [
 "gpui",
 "http_client",
 "language",
+ "libc",
 "log",
 "node_runtime",
 "parking_lot",
@@ -4048,7 +4051,7 @@ dependencies = [
 [[package]]
 name = "dap-types"
 version = "0.0.1"
-source = "git+https://github.com/zed-industries/dap-types?rev=68516de327fa1be15214133a0a2e52a12982ce75#68516de327fa1be15214133a0a2e52a12982ce75"
+source = "git+https://github.com/zed-industries/dap-types?rev=b40956a7f4d1939da67429d941389ee306a3a308#b40956a7f4d1939da67429d941389ee306a3a308"
 dependencies = [
 "schemars",
 "serde",
@@ -4061,6 +4064,7 @@ version = "0.1.0"
 dependencies = [
 "anyhow",
 "async-trait",
+ "collections",
 "dap",
 "futures 0.3.31",
 "gpui",
@@ -4234,6 +4238,7 @@ dependencies = [
 "futures 0.3.31",
 "fuzzy",
 "gpui",
+ "itertools 0.14.0",
 "language",
 "log",
 "menu",
@@ -4691,7 +4696,6 @@ dependencies = [
 "client",
 "clock",
 "collections",
- "command_palette_hooks",
 "convert_case 0.8.0",
 "ctor",
 "dap",
@@ -5013,7 +5017,6 @@ dependencies = [
 "assistant_tool",
 "assistant_tools",
 "async-trait",
- "async-watch",
 "buffer_diff",
 "chrono",
 "clap",
@@ -5055,6 +5058,7 @@ dependencies = [
 "unindent",
 "util",
 "uuid",
+ "watch",
 "workspace-hack",
 "zed_llm_client",
 ]
@@ -8739,7 +8743,6 @@ version = "0.1.0"
 dependencies = [
 "anyhow",
 "async-trait",
- "async-watch",
 "clock",
 "collections",
 "ctor",
@@ -8789,6 +8792,7 @@ dependencies = [
 "unicase",
 "unindent",
 "util",
+ "watch",
 "workspace-hack",
 "zlog",
 ]
@@ -8999,7 +9003,6 @@ dependencies = [
 "tree-sitter-yaml",
 "unindent",
 "util",
- "which 6.0.3",
 "workspace",
 "workspace-hack",
 ]
@@ -10138,6 +10141,18 @@ dependencies = [
 "memoffset",
 ]

+[[package]]
+name = "nix"
+version = "0.30.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "74523f3a35e05aba87a1d978330aef40f67b0304ac79c1c00b294c9830543db6"
+dependencies = [
+ "bitflags 2.9.0",
+ "cfg-if",
+ "cfg_aliases 0.2.1",
+ "libc",
+]
+
 [[package]]
 name = "node_runtime"
 version = "0.1.0"
@@ -10147,7 +10162,6 @@ dependencies = [
 "async-std",
 "async-tar",
 "async-trait",
- "async-watch",
 "futures 0.3.31",
 "http_client",
 "log",
@@ -10157,6 +10171,7 @@ dependencies = [
 "serde_json",
 "smol",
 "util",
+ "watch",
 "which 6.0.3",
 "workspace-hack",
 ]
@@ -10205,6 +10220,7 @@ dependencies = [
 "util",
 "workspace",
 "workspace-hack",
+ "zed_actions",
 ]

 [[package]]
@@ -12117,7 +12133,6 @@ dependencies = [
 "unindent",
 "url",
 "util",
- "uuid",
 "which 6.0.3",
 "workspace-hack",
 "worktree",
@@ -13006,7 +13021,6 @@ dependencies = [
 "askpass",
 "assistant_tool",
 "assistant_tools",
- "async-watch",
 "backtrace",
 "cargo_toml",
 "chrono",
@@ -13053,6 +13067,7 @@ dependencies = [
 "toml 0.8.20",
 "unindent",
 "util",
+ "watch",
 "worktree",
 "zlog",
 ]
@@ -15732,6 +15747,7 @@ dependencies = [
 "task",
 "theme",
 "thiserror 2.0.12",
+ "url",
 "util",
 "windows 0.61.1",
 "workspace-hack",
@@ -17128,6 +17144,7 @@ dependencies = [
 "async-fs",
 "async_zip",
 "collections",
+ "command-fds",
 "dirs 4.0.0",
 "dunce",
 "futures 0.3.31",
@@ -17913,6 +17930,19 @@ dependencies = [
 "leb128",
 ]

+[[package]]
+name = "watch"
+version = "0.1.0"
+dependencies = [
+ "ctor",
+ "futures 0.3.31",
+ "gpui",
+ "parking_lot",
+ "rand 0.8.5",
+ "workspace-hack",
+ "zlog",
+]
+
 [[package]]
 name = "wayland-backend"
 version = "0.3.8"
@@ -19724,7 +19754,6 @@ dependencies = [
 "assistant_context_editor",
 "assistant_tool",
 "assistant_tools",
- "async-watch",
 "audio",
 "auto_update",
 "auto_update_ui",
@@ -19841,6 +19870,7 @@ dependencies = [
 "uuid",
 "vim",
 "vim_mode_setting",
+ "watch",
 "web_search",
 "web_search_providers",
 "welcome",
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -165,6 +165,7 @@ members = [
    "crates/util_macros",
    "crates/vim",
    "crates/vim_mode_setting",
+    "crates/watch",
    "crates/web_search",
    "crates/web_search_providers",
    "crates/welcome",
@@ -373,6 +374,7 @@ util = { path = "crates/util" }
 util_macros = { path = "crates/util_macros" }
 vim = { path = "crates/vim" }
 vim_mode_setting = { path = "crates/vim_mode_setting" }
+watch = { path = "crates/watch" }
 web_search = { path = "crates/web_search" }
 web_search_providers = { path = "crates/web_search_providers" }
 welcome = { path = "crates/welcome" }
@@ -403,7 +405,6 @@ async-recursion = "1.0.0"
 async-tar = "0.5.0"
 async-trait = "0.1"
 async-tungstenite = "0.29.1"
-async-watch = "0.3.1"
 async_zip = { version = "0.0.17", features = ["deflate", "deflate64"] }
 aws-config = { version = "1.6.1", features = ["behavior-version-latest"] }
 aws-credential-types = { version = "1.2.2", features = [
@@ -434,7 +435,7 @@ core-foundation-sys = "0.8.6"
 core-video = { version = "0.4.3", features = ["metal"] }
 criterion = { version = "0.5", features = ["html_reports"] }
 ctor = "0.4.0"
-dap-types = { git = "https://github.com/zed-industries/dap-types", rev = "68516de327fa1be15214133a0a2e52a12982ce75" }
+dap-types = { git = "https://github.com/zed-industries/dap-types", rev = "b40956a7f4d1939da67429d941389ee306a3a308" }
 dashmap = "6.0"
 derive_more = "0.99.17"
 dirs = "4.0"
@@ -697,6 +698,8 @@ codegen-units = 16
 [profile.dev.package]
 taffy = { opt-level = 3 }
 cranelift-codegen = { opt-level = 3 }
+cranelift-codegen-meta = { opt-level = 3 }
+cranelift-codegen-shared = { opt-level = 3 }
 resvg = { opt-level = 3 }
 rustybuzz = { opt-level = 3 }
 ttf-parser = { opt-level = 3 }
--- a/assets/icons/circle_help.svg
+++ b/assets/icons/circle_help.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-circle-help-icon lucide-circle-help"><circle cx="12" cy="12" r="10"/><path d="M9.09 9a3 3 0 0 1 5.83 1c0 2-3 3-3 3"/><path d="M12 17h.01"/></svg>
--- a/assets/keymaps/default-linux.json
+++ b/assets/keymaps/default-linux.json
@@ -35,7 +35,7 @@
      "ctrl-shift-f5": "debugger::Restart",
      "f6": "debugger::Pause",
      "f7": "debugger::StepOver",
-      "cmd-f11": "debugger::StepInto",
+      "ctrl-f11": "debugger::StepInto",
      "shift-f11": "debugger::StepOut",
      "f11": "zed::ToggleFullScreen",
      "ctrl-alt-z": "edit_prediction::RateCompletions",
@@ -59,7 +59,6 @@
      "tab": "editor::Tab",
      "shift-tab": "editor::Backtab",
      "ctrl-k": "editor::CutToEndOfLine",
-      // "ctrl-t": "editor::Transpose",
      "ctrl-k ctrl-q": "editor::Rewrap",
      "ctrl-k q": "editor::Rewrap",
      "ctrl-backspace": "editor::DeleteToPreviousWordStart",
@@ -100,21 +99,16 @@
      "shift-down": "editor::SelectDown",
      "shift-left": "editor::SelectLeft",
      "shift-right": "editor::SelectRight",
-      "ctrl-shift-left": "editor::SelectToPreviousWordStart", // cursorWordLeftSelect
-      "ctrl-shift-right": "editor::SelectToNextWordEnd", // cursorWordRightSelect
+      "ctrl-shift-left": "editor::SelectToPreviousWordStart",
+      "ctrl-shift-right": "editor::SelectToNextWordEnd",
      "ctrl-shift-home": "editor::SelectToBeginning",
      "ctrl-shift-end": "editor::SelectToEnd",
      "ctrl-a": "editor::SelectAll",
      "ctrl-l": "editor::SelectLine",
      "ctrl-shift-i": "editor::Format",
      "alt-shift-o": "editor::OrganizeImports",
-      // "cmd-shift-left": ["editor::SelectToBeginningOfLine", {"stop_at_soft_wraps": true, "stop_at_indent": true }],
-      // "ctrl-shift-a": ["editor::SelectToBeginningOfLine", { "stop_at_soft_wraps": true, "stop_at_indent": true }],
      "shift-home": ["editor::SelectToBeginningOfLine", { "stop_at_soft_wraps": true, "stop_at_indent": true }],
-      // "cmd-shift-right": ["editor::SelectToEndOfLine", { "stop_at_soft_wraps": true }],
-      // "ctrl-shift-e": ["editor::SelectToEndOfLine", { "stop_at_soft_wraps": true }],
      "shift-end": ["editor::SelectToEndOfLine", { "stop_at_soft_wraps": true }],
-      // "alt-v": ["editor::MovePageUp", { "center_cursor": true }],
      "ctrl-alt-space": "editor::ShowCharacterPalette",
      "ctrl-;": "editor::ToggleLineNumbers",
      "ctrl-'": "editor::ToggleSelectedDiffHunks",
@@ -140,7 +134,6 @@
      "find": "buffer_search::Deploy",
      "ctrl-f": "buffer_search::Deploy",
      "ctrl-h": "buffer_search::DeployReplace",
-      // "cmd-e": ["buffer_search::Deploy", { "focus": false }],
      "ctrl->": "assistant::QuoteSelection",
      "ctrl-<": "assistant::InsertIntoEditor",
      "ctrl-alt-e": "editor::SelectEnclosingSymbol",
@@ -153,8 +146,7 @@
    "context": "Editor && mode == full && edit_prediction",
    "bindings": {
      "alt-]": "editor::NextEditPrediction",
-      "alt-[": "editor::PreviousEditPrediction",
-      "alt-right": "editor::AcceptPartialEditPrediction"
+      "alt-[": "editor::PreviousEditPrediction"
    }
  },
  {
@@ -219,7 +211,6 @@
      "ctrl-enter": "assistant::Assist",
      "ctrl-s": "workspace::Save",
      "save": "workspace::Save",
-      "ctrl->": "assistant::QuoteSelection",
      "ctrl-<": "assistant::InsertIntoEditor",
      "shift-enter": "assistant::Split",
      "ctrl-r": "assistant::CycleMessageRole",
@@ -245,6 +236,7 @@
      "ctrl-shift-j": "agent::ToggleNavigationMenu",
      "ctrl-shift-i": "agent::ToggleOptionsMenu",
      "shift-alt-escape": "agent::ExpandMessageEditor",
+      "ctrl->": "assistant::QuoteSelection",
      "ctrl-alt-e": "agent::RemoveAllContext",
      "ctrl-shift-e": "project_panel::ToggleFocus",
      "ctrl-shift-enter": "agent::ContinueThread",
@@ -268,8 +260,8 @@
  {
    "context": "AgentPanel && prompt_editor",
    "bindings": {
-      "cmd-n": "agent::NewTextThread",
-      "cmd-alt-t": "agent::NewThread"
+      "ctrl-n": "agent::NewTextThread",
+      "ctrl-alt-t": "agent::NewThread"
    }
  },
  {
@@ -662,14 +654,16 @@
    "bindings": {
      "alt-tab": "editor::AcceptEditPrediction",
      "alt-l": "editor::AcceptEditPrediction",
-      "tab": "editor::AcceptEditPrediction"
+      "tab": "editor::AcceptEditPrediction",
+      "alt-right": "editor::AcceptPartialEditPrediction"
    }
  },
  {
    "context": "Editor && edit_prediction_conflict",
    "bindings": {
      "alt-tab": "editor::AcceptEditPrediction",
-      "alt-l": "editor::AcceptEditPrediction"
+      "alt-l": "editor::AcceptEditPrediction",
+      "alt-right": "editor::AcceptPartialEditPrediction"
    }
  },
  {
--- a/assets/keymaps/default-macos.json
+++ b/assets/keymaps/default-macos.json
@@ -181,8 +181,7 @@
    "use_key_equivalents": true,
    "bindings": {
      "alt-tab": "editor::NextEditPrediction",
-      "alt-shift-tab": "editor::PreviousEditPrediction",
-      "ctrl-cmd-right": "editor::AcceptPartialEditPrediction"
+      "alt-shift-tab": "editor::PreviousEditPrediction"
    }
  },
  {
@@ -253,7 +252,6 @@
    "bindings": {
      "cmd-enter": "assistant::Assist",
      "cmd-s": "workspace::Save",
-      "cmd->": "assistant::QuoteSelection",
      "cmd-<": "assistant::InsertIntoEditor",
      "shift-enter": "assistant::Split",
      "ctrl-r": "assistant::CycleMessageRole",
@@ -280,6 +278,7 @@
      "cmd-shift-j": "agent::ToggleNavigationMenu",
      "cmd-shift-i": "agent::ToggleOptionsMenu",
      "shift-alt-escape": "agent::ExpandMessageEditor",
+      "cmd->": "assistant::QuoteSelection",
      "cmd-alt-e": "agent::RemoveAllContext",
      "cmd-shift-e": "project_panel::ToggleFocus",
      "cmd-shift-enter": "agent::ContinueThread",
@@ -719,14 +718,16 @@
    "context": "Editor && edit_prediction",
    "bindings": {
      "alt-tab": "editor::AcceptEditPrediction",
-      "tab": "editor::AcceptEditPrediction"
+      "tab": "editor::AcceptEditPrediction",
+      "ctrl-cmd-right": "editor::AcceptPartialEditPrediction"
    }
  },
  {
    "context": "Editor && edit_prediction_conflict",
    "use_key_equivalents": true,
    "bindings": {
-      "alt-tab": "editor::AcceptEditPrediction"
+      "alt-tab": "editor::AcceptEditPrediction",
+      "ctrl-cmd-right": "editor::AcceptPartialEditPrediction"
    }
  },
  {
--- a/assets/keymaps/initial.json
+++ b/assets/keymaps/initial.json
@@ -13,9 +13,9 @@
    }
  },
  {
-    "context": "Editor",
+    "context": "Editor && vim_mode == insert && !menu",
    "bindings": {
-      // "j k": ["workspace::SendKeystrokes", "escape"]
+      // "j k": "vim::SwitchToNormalMode"
    }
  }
 ]
--- a/assets/keymaps/linux/sublime_text.json
+++ b/assets/keymaps/linux/sublime_text.json
@@ -38,7 +38,7 @@
      "ctrl-shift-d": "editor::DuplicateSelection",
      "alt-f3": "editor::SelectAllMatches", // find_all_under
      // "ctrl-f3": "", // find_under (cancels any selections)
-      // "cmd-alt-shift-g": "" // find_under_prev (cancels any selections)
+      // "ctrl-alt-shift-g": "" // find_under_prev (cancels any selections)
      "f9": "editor::SortLinesCaseSensitive",
      "ctrl-f9": "editor::SortLinesCaseInsensitive",
      "f12": "editor::GoToDefinition",
--- a/assets/keymaps/macos/cursor.json
+++ b/assets/keymaps/macos/cursor.json
@@ -28,7 +28,8 @@
    "context": "InlineAssistEditor",
    "use_key_equivalents": true,
    "bindings": {
-      "cmd-shift-backspace": "editor::Cancel"
+      "cmd-shift-backspace": "editor::Cancel",
+      "cmd-enter": "menu::Confirm"
      // "alt-enter": // Quick Question
      // "cmd-shift-enter": // Full File Context
      // "cmd-shift-k": // Toggle input focus (editor <> inline assist)
--- a/assets/keymaps/vim.json
+++ b/assets/keymaps/vim.json
@@ -395,6 +395,8 @@
      "ctrl-pagedown": "pane::ActivateNextItem",
      "ctrl-pageup": "pane::ActivatePreviousItem",
      "insert": "vim::InsertBefore",
+      ".": "vim::Repeat",
+      "alt-.": "vim::RepeatFind",
      // tree-sitter related commands
      "[ x": "editor::SelectLargerSyntaxNode",
      "] x": "editor::SelectSmallerSyntaxNode",
@@ -421,6 +423,7 @@

      "x": "editor::SelectLine",
      "shift-x": "editor::SelectLine",
+      "%": "editor::SelectAll",
      // Window mode
      "space w h": "workspace::ActivatePaneLeft",
      "space w l": "workspace::ActivatePaneRight",
@@ -450,7 +453,8 @@
      "ctrl-c": "editor::ToggleComments",
      "d": "vim::HelixDelete",
      "c": "vim::Substitute",
-      "shift-c": "editor::AddSelectionBelow"
+      "shift-c": "editor::AddSelectionBelow",
+      "alt-shift-c": "editor::AddSelectionAbove"
    }
  },
  {
@@ -711,7 +715,7 @@
    }
  },
  {
-    "context": "GitPanel || ProjectPanel || CollabPanel || OutlinePanel || ChatPanel || VimControl || EmptyPane || SharedScreen || MarkdownPreview || KeyContextView || DebugPanel",
+    "context": "AgentPanel || GitPanel || ProjectPanel || CollabPanel || OutlinePanel || ChatPanel || VimControl || EmptyPane || SharedScreen || MarkdownPreview || KeyContextView || DebugPanel",
    "bindings": {
      // window related commands (ctrl-w X)
      "ctrl-w": null,
--- a/assets/settings/default.json
+++ b/assets/settings/default.json
@@ -101,9 +101,12 @@
    // The second option is decimal.
    "unit": "binary"
  },
-  // The key to use for adding multiple cursors
-  // Currently "alt" or "cmd_or_ctrl"  (also aliased as
-  // "cmd" and "ctrl") are supported.
+  // Determines the modifier to be used to add multiple cursors with the mouse. The open hover link mouse gestures will adapt such that it do not conflict with the multicursor modifier.
+  //
+  // 1. Maps to `Alt` on Linux and Windows and to `Option` on MacOS:
+  //    "alt"
+  // 2. Maps `Control` on Linux and Windows and to `Command` on MacOS:
+  //    "cmd_or_ctrl" (alias: "cmd", "ctrl")
  "multi_cursor_modifier": "alt",
  // Whether to enable vim modes and key bindings.
  "vim_mode": false,
@@ -214,6 +217,8 @@
  "show_signature_help_after_edits": false,
  // Whether to show code action button at start of buffer line.
  "inline_code_actions": true,
+  // Whether to allow drag and drop text selection in buffer.
+  "drag_and_drop_selection": true,
  // What to do when go to definition yields no results.
  //
  // 1. Do nothing: `none`
@@ -440,7 +445,9 @@
    // Whether to show breakpoints in the gutter.
    "breakpoints": true,
    // Whether to show fold buttons in the gutter.
-    "folds": true
+    "folds": true,
+    // Minimum number of characters to reserve space for in the gutter.
+    "min_line_number_digits": 4
  },
  "indent_guides": {
    // Whether to show indent guides in the editor.
@@ -599,7 +606,9 @@
      // 2. Never show indent guides:
      //    "never"
      "show": "always"
-    }
+    },
+    // Whether to hide the root entry when only one folder is open in the window.
+    "hide_root": false
  },
  "outline_panel": {
    // Whether to show the outline panel button in the status bar
@@ -771,7 +780,6 @@
        "tools": {
          "copy_path": true,
          "create_directory": true,
-          "create_file": true,
          "delete_path": true,
          "diagnostics": true,
          "edit_file": true,
@@ -1034,6 +1042,14 @@
    "button": true,
    // Whether to show warnings or not by default.
    "include_warnings": true,
+    // Settings for using LSP pull diagnostics mechanism in Zed.
+    "lsp_pull_diagnostics": {
+      // Whether to pull for diagnostics or not.
+      "enabled": true,
+      // Minimum time to wait before pulling diagnostics from the language server(s).
+      // 0 turns the debounce off.
+      "debounce_ms": 50
+    },
    // Settings for inline diagnostics
    "inline": {
      // Whether to show diagnostics inline or not
@@ -1457,12 +1473,15 @@
      "language_servers": ["erlang-ls", "!elp", "..."]
    },
    "Git Commit": {
-      "allow_rewrap": "anywhere"
+      "allow_rewrap": "anywhere",
+      "soft_wrap": "editor_width",
+      "preferred_line_length": 72
    },
    "Go": {
      "code_actions_on_format": {
        "source.organizeImports": true
-      }
+      },
+      "debuggers": ["Delve"]
    },
    "GraphQL": {
      "prettier": {
@@ -1527,20 +1546,20 @@
    "Plain Text": {
      "allow_rewrap": "anywhere"
    },
+    "Python": {
+      "debuggers": ["Debugpy"]
+    },
    "Ruby": {
      "language_servers": ["solargraph", "!ruby-lsp", "!rubocop", "!sorbet", "!steep", "..."]
    },
+    "Rust": {
+      "debuggers": ["CodeLLDB"]
+    },
    "SCSS": {
      "prettier": {
        "allowed": true
      }
    },
-    "SQL": {
-      "prettier": {
-        "allowed": true,
-        "plugins": ["prettier-plugin-sql"]
-      }
-    },
    "Starlark": {
      "language_servers": ["starpls", "!buck2-lsp", "..."]
    },
--- a/assets/settings/initial_tasks.json
+++ b/assets/settings/initial_tasks.json
@@ -1,4 +1,4 @@
-// Static tasks configuration.
+// Project tasks configuration. See https://zed.dev/docs/tasks for documentation.
 //
 // Example:
 [
--- a/assets/themes/ayu/ayu.json
+++ b/assets/themes/ayu/ayu.json
@@ -261,6 +261,11 @@
            "font_style": null,
            "font_weight": null
          },
+          "namespace": {
+            "color": "#bfbdb6ff",
+            "font_style": null,
+            "font_weight": null
+          },
          "number": {
            "color": "#d2a6ffff",
            "font_style": null,
@@ -316,6 +321,16 @@
            "font_style": null,
            "font_weight": null
          },
+          "selector": {
+            "color": "#d2a6ffff",
+            "font_style": null,
+            "font_weight": null
+          },
+          "selector.pseudo": {
+            "color": "#5ac1feff",
+            "font_style": null,
+            "font_weight": null
+          },
          "string": {
            "color": "#a9d94bff",
            "font_style": null,
@@ -442,9 +457,9 @@
        "terminal.foreground": "#5c6166ff",
        "terminal.bright_foreground": "#5c6166ff",
        "terminal.dim_foreground": "#fcfcfcff",
-        "terminal.ansi.black": "#fcfcfcff",
-        "terminal.ansi.bright_black": "#bcbec0ff",
-        "terminal.ansi.dim_black": "#5c6166ff",
+        "terminal.ansi.black": "#5c6166ff",
+        "terminal.ansi.bright_black": "#3b9ee5ff",
+        "terminal.ansi.dim_black": "#9c9fa2ff",
        "terminal.ansi.red": "#ef7271ff",
        "terminal.ansi.bright_red": "#febab6ff",
        "terminal.ansi.dim_red": "#833538ff",
@@ -463,9 +478,9 @@
        "terminal.ansi.cyan": "#4dbf99ff",
        "terminal.ansi.bright_cyan": "#ace0cbff",
        "terminal.ansi.dim_cyan": "#2a5f4aff",
-        "terminal.ansi.white": "#5c6166ff",
-        "terminal.ansi.bright_white": "#5c6166ff",
-        "terminal.ansi.dim_white": "#9c9fa2ff",
+        "terminal.ansi.white": "#fcfcfcff",
+        "terminal.ansi.bright_white": "#fcfcfcff",
+        "terminal.ansi.dim_white": "#bcbec0ff",
        "link_text.hover": "#3b9ee5ff",
        "conflict": "#f1ad49ff",
        "conflict.background": "#ffeedaff",
@@ -632,6 +647,11 @@
            "font_style": null,
            "font_weight": null
          },
+          "namespace": {
+            "color": "#5c6166ff",
+            "font_style": null,
+            "font_weight": null
+          },
          "number": {
            "color": "#a37accff",
            "font_style": null,
@@ -687,6 +707,16 @@
            "font_style": null,
            "font_weight": null
          },
+          "selector": {
+            "color": "#a37accff",
+            "font_style": null,
+            "font_weight": null
+          },
+          "selector.pseudo": {
+            "color": "#3b9ee5ff",
+            "font_style": null,
+            "font_weight": null
+          },
          "string": {
            "color": "#86b300ff",
            "font_style": null,
@@ -1003,6 +1033,11 @@
            "font_style": null,
            "font_weight": null
          },
+          "namespace": {
+            "color": "#cccac2ff",
+            "font_style": null,
+            "font_weight": null
+          },
          "number": {
            "color": "#dfbfffff",
            "font_style": null,
@@ -1058,6 +1093,16 @@
            "font_style": null,
            "font_weight": null
          },
+          "selector": {
+            "color": "#dfbfffff",
+            "font_style": null,
+            "font_weight": null
+          },
+          "selector.pseudo": {
+            "color": "#72cffeff",
+            "font_style": null,
+            "font_weight": null
+          },
          "string": {
            "color": "#d4fe7fff",
            "font_style": null,
--- a/assets/themes/gruvbox/gruvbox.json
+++ b/assets/themes/gruvbox/gruvbox.json
@@ -270,6 +270,11 @@
            "font_style": null,
            "font_weight": null
          },
+          "namespace": {
+            "color": "#83a598ff",
+            "font_style": null,
+            "font_weight": null
+          },
          "number": {
            "color": "#d3869bff",
            "font_style": null,
@@ -325,6 +330,16 @@
            "font_style": null,
            "font_weight": null
          },
+          "selector": {
+            "color": "#fabd2eff",
+            "font_style": null,
+            "font_weight": null
+          },
+          "selector.pseudo": {
+            "color": "#83a598ff",
+            "font_style": null,
+            "font_weight": null
+          },
          "string": {
            "color": "#b8bb25ff",
            "font_style": null,
@@ -655,6 +670,11 @@
            "font_style": null,
            "font_weight": null
          },
+          "namespace": {
+            "color": "#83a598ff",
+            "font_style": null,
+            "font_weight": null
+          },
          "number": {
            "color": "#d3869bff",
            "font_style": null,
@@ -710,6 +730,16 @@
            "font_style": null,
            "font_weight": null
          },
+          "selector": {
+            "color": "#fabd2eff",
+            "font_style": null,
+            "font_weight": null
+          },
+          "selector.pseudo": {
+            "color": "#83a598ff",
+            "font_style": null,
+            "font_weight": null
+          },
          "string": {
            "color": "#b8bb25ff",
            "font_style": null,
@@ -1040,6 +1070,11 @@
            "font_style": null,
            "font_weight": null
          },
+          "namespace": {
+            "color": "#83a598ff",
+            "font_style": null,
+            "font_weight": null
+          },
          "number": {
            "color": "#d3869bff",
            "font_style": null,
@@ -1095,6 +1130,16 @@
            "font_style": null,
            "font_weight": null
          },
+          "selector": {
+            "color": "#fabd2eff",
+            "font_style": null,
+            "font_weight": null
+          },
+          "selector.pseudo": {
+            "color": "#83a598ff",
+            "font_style": null,
+            "font_weight": null
+          },
          "string": {
            "color": "#b8bb25ff",
            "font_style": null,
@@ -1227,9 +1272,9 @@
        "terminal.foreground": "#282828ff",
        "terminal.bright_foreground": "#282828ff",
        "terminal.dim_foreground": "#fbf1c7ff",
-        "terminal.ansi.black": "#fbf1c7ff",
-        "terminal.ansi.bright_black": "#b0a189ff",
-        "terminal.ansi.dim_black": "#282828ff",
+        "terminal.ansi.black": "#282828ff",
+        "terminal.ansi.bright_black": "#0b6678ff",
+        "terminal.ansi.dim_black": "#5f5650ff",
        "terminal.ansi.red": "#9d0308ff",
        "terminal.ansi.bright_red": "#db8b7aff",
        "terminal.ansi.dim_red": "#4e1207ff",
@@ -1248,9 +1293,9 @@
        "terminal.ansi.cyan": "#437b59ff",
        "terminal.ansi.bright_cyan": "#9fbca8ff",
        "terminal.ansi.dim_cyan": "#253e2eff",
-        "terminal.ansi.white": "#282828ff",
-        "terminal.ansi.bright_white": "#282828ff",
-        "terminal.ansi.dim_white": "#73675eff",
+        "terminal.ansi.white": "#fbf1c7ff",
+        "terminal.ansi.bright_white": "#fbf1c7ff",
+        "terminal.ansi.dim_white": "#b0a189ff",
        "link_text.hover": "#0b6678ff",
        "version_control.added": "#797410ff",
        "version_control.modified": "#b57615ff",
@@ -1425,6 +1470,11 @@
            "font_style": null,
            "font_weight": null
          },
+          "namespace": {
+            "color": "#066578ff",
+            "font_style": null,
+            "font_weight": null
+          },
          "number": {
            "color": "#8f3e71ff",
            "font_style": null,
@@ -1480,6 +1530,16 @@
            "font_style": null,
            "font_weight": null
          },
+          "selector": {
+            "color": "#b57613ff",
+            "font_style": null,
+            "font_weight": null
+          },
+          "selector.pseudo": {
+            "color": "#0b6678ff",
+            "font_style": null,
+            "font_weight": null
+          },
          "string": {
            "color": "#79740eff",
            "font_style": null,
@@ -1612,9 +1672,9 @@
        "terminal.foreground": "#282828ff",
        "terminal.bright_foreground": "#282828ff",
        "terminal.dim_foreground": "#f9f5d7ff",
-        "terminal.ansi.black": "#f9f5d7ff",
-        "terminal.ansi.bright_black": "#b0a189ff",
-        "terminal.ansi.dim_black": "#282828ff",
+        "terminal.ansi.black": "#282828ff",
+        "terminal.ansi.bright_black": "#73675eff",
+        "terminal.ansi.dim_black": "#f9f5d7ff",
        "terminal.ansi.red": "#9d0308ff",
        "terminal.ansi.bright_red": "#db8b7aff",
        "terminal.ansi.dim_red": "#4e1207ff",
@@ -1633,9 +1693,9 @@
        "terminal.ansi.cyan": "#437b59ff",
        "terminal.ansi.bright_cyan": "#9fbca8ff",
        "terminal.ansi.dim_cyan": "#253e2eff",
-        "terminal.ansi.white": "#282828ff",
-        "terminal.ansi.bright_white": "#282828ff",
-        "terminal.ansi.dim_white": "#73675eff",
+        "terminal.ansi.white": "#f9f5d7ff",
+        "terminal.ansi.bright_white": "#f9f5d7ff",
+        "terminal.ansi.dim_white": "#b0a189ff",
        "link_text.hover": "#0b6678ff",
        "version_control.added": "#797410ff",
        "version_control.modified": "#b57615ff",
@@ -1810,6 +1870,11 @@
            "font_style": null,
            "font_weight": null
          },
+          "namespace": {
+            "color": "#066578ff",
+            "font_style": null,
+            "font_weight": null
+          },
          "number": {
            "color": "#8f3e71ff",
            "font_style": null,
@@ -1865,6 +1930,16 @@
            "font_style": null,
            "font_weight": null
          },
+          "selector": {
+            "color": "#b57613ff",
+            "font_style": null,
+            "font_weight": null
+          },
+          "selector.pseudo": {
+            "color": "#0b6678ff",
+            "font_style": null,
+            "font_weight": null
+          },
          "string": {
            "color": "#79740eff",
            "font_style": null,
@@ -1997,9 +2072,9 @@
        "terminal.foreground": "#282828ff",
        "terminal.bright_foreground": "#282828ff",
        "terminal.dim_foreground": "#f2e5bcff",
-        "terminal.ansi.black": "#f2e5bcff",
-        "terminal.ansi.bright_black": "#b0a189ff",
-        "terminal.ansi.dim_black": "#282828ff",
+        "terminal.ansi.black": "#282828ff",
+        "terminal.ansi.bright_black": "#73675eff",
+        "terminal.ansi.dim_black": "#f2e5bcff",
        "terminal.ansi.red": "#9d0308ff",
        "terminal.ansi.bright_red": "#db8b7aff",
        "terminal.ansi.dim_red": "#4e1207ff",
@@ -2018,9 +2093,9 @@
        "terminal.ansi.cyan": "#437b59ff",
        "terminal.ansi.bright_cyan": "#9fbca8ff",
        "terminal.ansi.dim_cyan": "#253e2eff",
-        "terminal.ansi.white": "#282828ff",
-        "terminal.ansi.bright_white": "#282828ff",
-        "terminal.ansi.dim_white": "#73675eff",
+        "terminal.ansi.white": "#f2e5bcff",
+        "terminal.ansi.bright_white": "#f2e5bcff",
+        "terminal.ansi.dim_white": "#b0a189ff",
        "link_text.hover": "#0b6678ff",
        "version_control.added": "#797410ff",
        "version_control.modified": "#b57615ff",
@@ -2195,6 +2270,11 @@
            "font_style": null,
            "font_weight": null
          },
+          "namespace": {
+            "color": "#066578ff",
+            "font_style": null,
+            "font_weight": null
+          },
          "number": {
            "color": "#8f3e71ff",
            "font_style": null,
@@ -2250,6 +2330,16 @@
            "font_style": null,
            "font_weight": null
          },
+          "selector": {
+            "color": "#b57613ff",
+            "font_style": null,
+            "font_weight": null
+          },
+          "selector.pseudo": {
+            "color": "#0b6678ff",
+            "font_style": null,
+            "font_weight": null
+          },
          "string": {
            "color": "#79740eff",
            "font_style": null,
--- a/assets/themes/one/one.json
+++ b/assets/themes/one/one.json
@@ -99,6 +99,8 @@
        "version_control.added": "#27a657ff",
        "version_control.modified": "#d3b020ff",
        "version_control.deleted": "#e06c76ff",
+        "version_control.conflict_marker.ours": "#a1c1811a",
+        "version_control.conflict_marker.theirs": "#74ade81a",
        "conflict": "#dec184ff",
        "conflict.background": "#dec1841a",
        "conflict.border": "#5d4c2fff",
@@ -264,6 +266,11 @@
            "font_style": null,
            "font_weight": null
          },
+          "namespace": {
+            "color": "#dce0e5ff",
+            "font_style": null,
+            "font_weight": null
+          },
          "number": {
            "color": "#bf956aff",
            "font_style": null,
@@ -319,6 +326,16 @@
            "font_style": null,
            "font_weight": null
          },
+          "selector": {
+            "color": "#dfc184ff",
+            "font_style": null,
+            "font_weight": null
+          },
+          "selector.pseudo": {
+            "color": "#74ade8ff",
+            "font_style": null,
+            "font_weight": null
+          },
          "string": {
            "color": "#a1c181ff",
            "font_style": null,
@@ -450,9 +467,9 @@
        "terminal.foreground": "#242529ff",
        "terminal.bright_foreground": "#242529ff",
        "terminal.dim_foreground": "#fafafaff",
-        "terminal.ansi.black": "#fafafaff",
-        "terminal.ansi.bright_black": "#aaaaaaff",
-        "terminal.ansi.dim_black": "#242529ff",
+        "terminal.ansi.black": "#242529ff",
+        "terminal.ansi.bright_black": "#242529ff",
+        "terminal.ansi.dim_black": "#97979aff",
        "terminal.ansi.red": "#d36151ff",
        "terminal.ansi.bright_red": "#f0b0a4ff",
        "terminal.ansi.dim_red": "#6f312aff",
@@ -471,9 +488,9 @@
        "terminal.ansi.cyan": "#3a82b7ff",
        "terminal.ansi.bright_cyan": "#a3bedaff",
        "terminal.ansi.dim_cyan": "#254058ff",
-        "terminal.ansi.white": "#242529ff",
-        "terminal.ansi.bright_white": "#242529ff",
-        "terminal.ansi.dim_white": "#97979aff",
+        "terminal.ansi.white": "#fafafaff",
+        "terminal.ansi.bright_white": "#fafafaff",
+        "terminal.ansi.dim_white": "#aaaaaaff",
        "link_text.hover": "#5c78e2ff",
        "version_control.added": "#27a657ff",
        "version_control.modified": "#d3b020ff",
@@ -643,6 +660,11 @@
            "font_style": null,
            "font_weight": null
          },
+          "namespace": {
+            "color": "#242529ff",
+            "font_style": null,
+            "font_weight": null
+          },
          "number": {
            "color": "#ad6e25ff",
            "font_style": null,
@@ -698,6 +720,16 @@
            "font_style": null,
            "font_weight": null
          },
+          "selector": {
+            "color": "#669f59ff",
+            "font_style": null,
+            "font_weight": null
+          },
+          "selector.pseudo": {
+            "color": "#5c78e2ff",
+            "font_style": null,
+            "font_weight": null
+          },
          "string": {
            "color": "#649f57ff",
            "font_style": null,
--- a/crates/agent/Cargo.toml
+++ b/crates/agent/Cargo.toml
@@ -25,7 +25,6 @@ assistant_context_editor.workspace = true
 assistant_slash_command.workspace = true
 assistant_slash_commands.workspace = true
 assistant_tool.workspace = true
-async-watch.workspace = true
 audio.workspace = true
 buffer_diff.workspace = true
 chrono.workspace = true
@@ -95,6 +94,7 @@ ui_input.workspace = true
 urlencoding.workspace = true
 util.workspace = true
 uuid.workspace = true
+watch.workspace = true
 workspace-hack.workspace = true
 workspace.workspace = true
 zed_actions.workspace = true
@@ -102,11 +102,13 @@ zed_llm_client.workspace = true
 zstd.workspace = true

 [dev-dependencies]
+assistant_tools.workspace = true
 buffer_diff = { workspace = true, features = ["test-support"] }
 editor = { workspace = true, features = ["test-support"] }
 gpui = { workspace = true, "features" = ["test-support"] }
 indoc.workspace = true
 language = { workspace = true, "features" = ["test-support"] }
 language_model = { workspace = true, "features" = ["test-support"] }
+pretty_assertions.workspace = true
 project = { workspace = true, features = ["test-support"] }
 rand.workspace = true
--- a/crates/agent/src/active_thread.rs
+++ b/crates/agent/src/active_thread.rs
@@ -1144,6 +1144,10 @@ impl ActiveThread {
                    cx,
                );
            }
+            ThreadEvent::ProfileChanged => {
+                self.save_thread(cx);
+                cx.notify();
+            }
        }
    }

@@ -1601,6 +1605,7 @@ impl ActiveThread {

                        this.thread.update(cx, |thread, cx| {
                            thread.advance_prompt_id();
+                            thread.cancel_last_completion(Some(window.window_handle()), cx);
                            thread.send_to_model(
                                model.model,
                                CompletionIntent::UserPrompt,
@@ -1784,12 +1789,31 @@ impl ActiveThread {

    fn render_message(&self, ix: usize, window: &mut Window, cx: &mut Context<Self>) -> AnyElement {
        let message_id = self.messages[ix];
-        let Some(message) = self.thread.read(cx).message(message_id) else {
+        let workspace = self.workspace.clone();
+        let thread = self.thread.read(cx);
+
+        let is_first_message = ix == 0;
+        let is_last_message = ix == self.messages.len() - 1;
+
+        let Some(message) = thread.message(message_id) else {
            return Empty.into_any();
        };

+        let is_generating = thread.is_generating();
+        let is_generating_stale = thread.is_generation_stale().unwrap_or(false);
+
+        let loading_dots = (is_generating && is_last_message).then(|| {
+            h_flex()
+                .h_8()
+                .my_3()
+                .mx_5()
+                .when(is_generating_stale || message.is_hidden, |this| {
+                    this.child(AnimatedLabel::new("").size(LabelSize::Small))
+                })
+        });
+
        if message.is_hidden {
-            return Empty.into_any();
+            return div().children(loading_dots).into_any();
        }

        let message_creases = message.creases.clone();
@@ -1798,9 +1822,6 @@ impl ActiveThread {
            return Empty.into_any();
        };

-        let workspace = self.workspace.clone();
-        let thread = self.thread.read(cx);
-
        // Get all the data we need from thread before we start using it in closures
        let checkpoint = thread.checkpoint_for_message(message_id);
        let configured_model = thread.configured_model().map(|m| m.model);
@@ -1811,14 +1832,6 @@ impl ActiveThread {

        let tool_uses = thread.tool_uses_for_message(message_id, cx);
        let has_tool_uses = !tool_uses.is_empty();
-        let is_generating = thread.is_generating();
-        let is_generating_stale = thread.is_generation_stale().unwrap_or(false);
-
-        let is_first_message = ix == 0;
-        let is_last_message = ix == self.messages.len() - 1;
-
-        let loading_dots = (is_generating_stale && is_last_message)
-            .then(|| AnimatedLabel::new("").size(LabelSize::Small));

        let editing_message_state = self
            .editing_message
@@ -2234,17 +2247,7 @@ impl ActiveThread {
                parent.child(self.render_rules_item(cx))
            })
            .child(styled_message)
-            .when(is_generating && is_last_message, |this| {
-                this.child(
-                    h_flex()
-                        .h_8()
-                        .mt_2()
-                        .mb_4()
-                        .ml_4()
-                        .py_1p5()
-                        .when_some(loading_dots, |this, loading_dots| this.child(loading_dots)),
-                )
-            })
+            .children(loading_dots)
            .when(show_feedback, move |parent| {
                parent.child(feedback_items).when_some(
                    self.open_feedback_editors.get(&message_id),
@@ -3704,7 +3707,7 @@ mod tests {
    use util::path;
    use workspace::CollaboratorId;

-    use crate::{ContextLoadResult, thread_store};
+    use crate::{ContextLoadResult, thread::MessageSegment, thread_store};

    use super::*;

@@ -3838,6 +3841,114 @@ mod tests {
        });
    }

+    #[gpui::test]
+    async fn test_editing_message_cancels_previous_completion(cx: &mut TestAppContext) {
+        init_test_settings(cx);
+
+        let project = create_test_project(cx, json!({})).await;
+
+        let (cx, active_thread, _, thread, model) =
+            setup_test_environment(cx, project.clone()).await;
+
+        cx.update(|_, cx| {
+            LanguageModelRegistry::global(cx).update(cx, |registry, cx| {
+                registry.set_default_model(
+                    Some(ConfiguredModel {
+                        provider: Arc::new(FakeLanguageModelProvider),
+                        model: model.clone(),
+                    }),
+                    cx,
+                );
+            });
+        });
+
+        // Track thread events to verify cancellation
+        let cancellation_events = Arc::new(std::sync::Mutex::new(Vec::new()));
+        let new_request_events = Arc::new(std::sync::Mutex::new(Vec::new()));
+
+        let _subscription = cx.update(|_, cx| {
+            let cancellation_events = cancellation_events.clone();
+            let new_request_events = new_request_events.clone();
+            cx.subscribe(
+                &thread,
+                move |_thread, event: &ThreadEvent, _cx| match event {
+                    ThreadEvent::CompletionCanceled => {
+                        cancellation_events.lock().unwrap().push(());
+                    }
+                    ThreadEvent::NewRequest => {
+                        new_request_events.lock().unwrap().push(());
+                    }
+                    _ => {}
+                },
+            )
+        });
+
+        // Insert a user message and start streaming a response
+        let message = thread.update(cx, |thread, cx| {
+            let message_id = thread.insert_user_message(
+                "Hello, how are you?",
+                ContextLoadResult::default(),
+                None,
+                vec![],
+                cx,
+            );
+            thread.advance_prompt_id();
+            thread.send_to_model(
+                model.clone(),
+                CompletionIntent::UserPrompt,
+                cx.active_window(),
+                cx,
+            );
+            thread.message(message_id).cloned().unwrap()
+        });
+
+        cx.run_until_parked();
+
+        // Verify that a completion is in progress
+        assert!(cx.read(|cx| thread.read(cx).is_generating()));
+        assert_eq!(new_request_events.lock().unwrap().len(), 1);
+
+        // Edit the message while the completion is still running
+        active_thread.update_in(cx, |active_thread, window, cx| {
+            active_thread.start_editing_message(
+                message.id,
+                message.segments.as_slice(),
+                message.creases.as_slice(),
+                window,
+                cx,
+            );
+            let editor = active_thread
+                .editing_message
+                .as_ref()
+                .unwrap()
+                .1
+                .editor
+                .clone();
+            editor.update(cx, |editor, cx| {
+                editor.set_text("What is the weather like?", window, cx);
+            });
+            active_thread.confirm_editing_message(&Default::default(), window, cx);
+        });
+
+        cx.run_until_parked();
+
+        // Verify that the previous completion was cancelled
+        assert_eq!(cancellation_events.lock().unwrap().len(), 1);
+
+        // Verify that a new request was started after cancellation
+        assert_eq!(new_request_events.lock().unwrap().len(), 2);
+
+        // Verify that the edited message contains the new text
+        let edited_message =
+            thread.update(cx, |thread, _| thread.message(message.id).cloned().unwrap());
+        match &edited_message.segments[0] {
+            MessageSegment::Text(text) => {
+                assert_eq!(text, "What is the weather like?");
+            }
+            _ => panic!("Expected text segment"),
+        }
+    }
+
    fn init_test_settings(cx: &mut TestAppContext) {
        cx.update(|cx| {
            let settings_store = SettingsStore::test(cx);
--- a/crates/agent/src/agent.rs
+++ b/crates/agent/src/agent.rs
@@ -3,6 +3,7 @@ mod agent_configuration;
 mod agent_diff;
 mod agent_model_selector;
 mod agent_panel;
+mod agent_profile;
 mod buffer_codegen;
 mod context;
 mod context_picker;
--- a/crates/agent/src/agent_configuration.rs
+++ b/crates/agent/src/agent_configuration.rs
@@ -12,7 +12,7 @@ use context_server::ContextServerId;
 use fs::Fs;
 use gpui::{
    Action, Animation, AnimationExt as _, AnyView, App, Entity, EventEmitter, FocusHandle,
-    Focusable, ScrollHandle, Subscription, pulsating_between,
+    Focusable, ScrollHandle, Subscription, Transformation, percentage,
 };
 use language_model::{LanguageModelProvider, LanguageModelProviderId, LanguageModelRegistry};
 use project::context_server_store::{ContextServerStatus, ContextServerStore};
@@ -475,7 +475,6 @@ impl AgentConfiguration {
            .get(&context_server_id)
            .copied()
            .unwrap_or_default();
-
        let tools = tools_by_source
            .get(&ToolSource::ContextServer {
                id: context_server_id.0.clone().into(),
@@ -484,25 +483,23 @@ impl AgentConfiguration {
        let tool_count = tools.len();

        let border_color = cx.theme().colors().border.opacity(0.6);
-        let success_color = Color::Success.color(cx);

        let (status_indicator, tooltip_text) = match server_status {
            ContextServerStatus::Starting => (
-                Indicator::dot()
-                    .color(Color::Success)
+                Icon::new(IconName::LoadCircle)
+                    .size(IconSize::XSmall)
+                    .color(Color::Accent)
                    .with_animation(
                        SharedString::from(format!("{}-starting", context_server_id.0.clone(),)),
-                        Animation::new(Duration::from_secs(2))
-                            .repeat()
-                            .with_easing(pulsating_between(0.4, 1.)),
-                        move |this, delta| this.color(success_color.alpha(delta).into()),
+                        Animation::new(Duration::from_secs(3)).repeat(),
+                        |icon, delta| icon.transform(Transformation::rotate(percentage(delta))),
                    )
                    .into_any_element(),
                "Server is starting.",
            ),
            ContextServerStatus::Running => (
                Indicator::dot().color(Color::Success).into_any_element(),
-                "Server is running.",
+                "Server is active.",
            ),
            ContextServerStatus::Error(_) => (
                Indicator::dot().color(Color::Error).into_any_element(),
@@ -526,12 +523,11 @@ impl AgentConfiguration {
                    .p_1()
                    .justify_between()
                    .when(
-                        error.is_some() || are_tools_expanded && tool_count > 1,
+                        error.is_some() || are_tools_expanded && tool_count >= 1,
                        |element| element.border_b_1().border_color(border_color),
                    )
                    .child(
                        h_flex()
-                            .gap_1p5()
                            .child(
                                Disclosure::new(
                                    "tool-list-disclosure",
@@ -551,12 +547,16 @@ impl AgentConfiguration {
                                })),
                            )
                            .child(
-                                div()
-                                    .id(item_id.clone())
+                                h_flex()
+                                    .id(SharedString::from(format!("tooltip-{}", item_id)))
+                                    .h_full()
+                                    .w_3()
+                                    .mx_1()
+                                    .justify_center()
                                    .tooltip(Tooltip::text(tooltip_text))
                                    .child(status_indicator),
                            )
-                            .child(Label::new(context_server_id.0.clone()).ml_0p5())
+                            .child(Label::new(item_id).ml_0p5().mr_1p5())
                            .when(is_running, |this| {
                                this.child(
                                    Label::new(if tool_count == 1 {
--- a/crates/agent/src/agent_configuration/manage_profiles_modal.rs
+++ b/crates/agent/src/agent_configuration/manage_profiles_modal.rs
@@ -2,25 +2,21 @@ mod profile_modal_header;

 use std::sync::Arc;

-use agent_settings::{AgentProfile, AgentProfileId, AgentSettings, builtin_profiles};
+use agent_settings::{AgentProfileId, AgentSettings, builtin_profiles};
 use assistant_tool::ToolWorkingSet;
-use convert_case::{Case, Casing as _};
 use editor::Editor;
 use fs::Fs;
-use gpui::{
-    DismissEvent, Entity, EventEmitter, FocusHandle, Focusable, Subscription, WeakEntity,
-    prelude::*,
-};
-use settings::{Settings as _, update_settings_file};
+use gpui::{DismissEvent, Entity, EventEmitter, FocusHandle, Focusable, Subscription, prelude::*};
+use settings::Settings as _;
 use ui::{
    KeyBinding, ListItem, ListItemSpacing, ListSeparator, Navigable, NavigableEntry, prelude::*,
 };
-use util::ResultExt as _;
 use workspace::{ModalView, Workspace};

 use crate::agent_configuration::manage_profiles_modal::profile_modal_header::ProfileModalHeader;
 use crate::agent_configuration::tool_picker::{ToolPicker, ToolPickerDelegate};
-use crate::{AgentPanel, ManageProfiles, ThreadStore};
+use crate::agent_profile::AgentProfile;
+use crate::{AgentPanel, ManageProfiles};

 use super::tool_picker::ToolPickerMode;

@@ -103,7 +99,6 @@ pub struct NewProfileMode {
 pub struct ManageProfilesModal {
    fs: Arc<dyn Fs>,
    tools: Entity<ToolWorkingSet>,
-    thread_store: WeakEntity<ThreadStore>,
    focus_handle: FocusHandle,
    mode: Mode,
 }
@@ -119,9 +114,8 @@ impl ManageProfilesModal {
                let fs = workspace.app_state().fs.clone();
                let thread_store = panel.read(cx).thread_store();
                let tools = thread_store.read(cx).tools();
-                let thread_store = thread_store.downgrade();
                workspace.toggle_modal(window, cx, |window, cx| {
-                    let mut this = Self::new(fs, tools, thread_store, window, cx);
+                    let mut this = Self::new(fs, tools, window, cx);

                    if let Some(profile_id) = action.customize_tools.clone() {
                        this.configure_builtin_tools(profile_id, window, cx);
@@ -136,7 +130,6 @@ impl ManageProfilesModal {
    pub fn new(
        fs: Arc<dyn Fs>,
        tools: Entity<ToolWorkingSet>,
-        thread_store: WeakEntity<ThreadStore>,
        window: &mut Window,
        cx: &mut Context<Self>,
    ) -> Self {
@@ -145,7 +138,6 @@ impl ManageProfilesModal {
        Self {
            fs,
            tools,
-            thread_store,
            focus_handle,
            mode: Mode::choose_profile(window, cx),
        }
@@ -206,7 +198,6 @@ impl ManageProfilesModal {
                ToolPickerMode::McpTools,
                self.fs.clone(),
                self.tools.clone(),
-                self.thread_store.clone(),
                profile_id.clone(),
                profile,
                cx,
@@ -244,7 +235,6 @@ impl ManageProfilesModal {
                ToolPickerMode::BuiltinTools,
                self.fs.clone(),
                self.tools.clone(),
-                self.thread_store.clone(),
                profile_id.clone(),
                profile,
                cx,
@@ -270,32 +260,10 @@ impl ManageProfilesModal {
        match &self.mode {
            Mode::ChooseProfile { .. } => {}
            Mode::NewProfile(mode) => {
-                let settings = AgentSettings::get_global(cx);
-
-                let base_profile = mode
-                    .base_profile_id
-                    .as_ref()
-                    .and_then(|profile_id| settings.profiles.get(profile_id).cloned());
-
                let name = mode.name_editor.read(cx).text(cx);
-                let profile_id = AgentProfileId(name.to_case(Case::Kebab).into());

-                let profile = AgentProfile {
-                    name: name.into(),
-                    tools: base_profile
-                        .as_ref()
-                        .map(|profile| profile.tools.clone())
-                        .unwrap_or_default(),
-                    enable_all_context_servers: base_profile
-                        .as_ref()
-                        .map(|profile| profile.enable_all_context_servers)
-                        .unwrap_or_default(),
-                    context_servers: base_profile
-                        .map(|profile| profile.context_servers)
-                        .unwrap_or_default(),
-                };
-
-                self.create_profile(profile_id.clone(), profile, cx);
+                let profile_id =
+                    AgentProfile::create(name, mode.base_profile_id.clone(), self.fs.clone(), cx);
                self.view_profile(profile_id, window, cx);
            }
            Mode::ViewProfile(_) => {}
@@ -325,19 +293,6 @@ impl ManageProfilesModal {
            }
        }
    }
-
-    fn create_profile(
-        &self,
-        profile_id: AgentProfileId,
-        profile: AgentProfile,
-        cx: &mut Context<Self>,
-    ) {
-        update_settings_file::<AgentSettings>(self.fs.clone(), cx, {
-            move |settings, _cx| {
-                settings.create_profile(profile_id, profile).log_err();
-            }
-        });
-    }
 }

 impl ModalView for ManageProfilesModal {}
@@ -520,14 +475,13 @@ impl ManageProfilesModal {
    ) -> impl IntoElement {
        let settings = AgentSettings::get_global(cx);

-        let profile_id = &settings.default_profile;
        let profile_name = settings
            .profiles
            .get(&mode.profile_id)
            .map(|profile| profile.name.clone())
            .unwrap_or_else(|| "Unknown".into());

-        let icon = match profile_id.as_str() {
+        let icon = match mode.profile_id.as_str() {
            "write" => IconName::Pencil,
            "ask" => IconName::MessageBubbles,
            _ => IconName::UserRoundPen,
--- a/crates/agent/src/agent_configuration/tool_picker.rs
+++ b/crates/agent/src/agent_configuration/tool_picker.rs
@@ -1,19 +1,17 @@
 use std::{collections::BTreeMap, sync::Arc};

 use agent_settings::{
-    AgentProfile, AgentProfileContent, AgentProfileId, AgentSettings, AgentSettingsContent,
+    AgentProfileContent, AgentProfileId, AgentProfileSettings, AgentSettings, AgentSettingsContent,
    ContextServerPresetContent,
 };
 use assistant_tool::{ToolSource, ToolWorkingSet};
 use fs::Fs;
 use gpui::{App, Context, DismissEvent, Entity, EventEmitter, Focusable, Task, WeakEntity, Window};
 use picker::{Picker, PickerDelegate};
-use settings::{Settings as _, update_settings_file};
+use settings::update_settings_file;
 use ui::{ListItem, ListItemSpacing, prelude::*};
 use util::ResultExt as _;

-use crate::ThreadStore;
-
 pub struct ToolPicker {
    picker: Entity<Picker<ToolPickerDelegate>>,
 }
@@ -71,11 +69,10 @@ pub enum PickerItem {

 pub struct ToolPickerDelegate {
    tool_picker: WeakEntity<ToolPicker>,
-    thread_store: WeakEntity<ThreadStore>,
    fs: Arc<dyn Fs>,
    items: Arc<Vec<PickerItem>>,
    profile_id: AgentProfileId,
-    profile: AgentProfile,
+    profile_settings: AgentProfileSettings,
    filtered_items: Vec<PickerItem>,
    selected_index: usize,
    mode: ToolPickerMode,
@@ -86,20 +83,18 @@ impl ToolPickerDelegate {
        mode: ToolPickerMode,
        fs: Arc<dyn Fs>,
        tool_set: Entity<ToolWorkingSet>,
-        thread_store: WeakEntity<ThreadStore>,
        profile_id: AgentProfileId,
-        profile: AgentProfile,
+        profile_settings: AgentProfileSettings,
        cx: &mut Context<ToolPicker>,
    ) -> Self {
        let items = Arc::new(Self::resolve_items(mode, &tool_set, cx));

        Self {
            tool_picker: cx.entity().downgrade(),
-            thread_store,
            fs,
            items,
            profile_id,
-            profile,
+            profile_settings,
            filtered_items: Vec::new(),
            selected_index: 0,
            mode,
@@ -249,28 +244,31 @@ impl PickerDelegate for ToolPickerDelegate {
        };

        let is_currently_enabled = if let Some(server_id) = server_id.clone() {
-            let preset = self.profile.context_servers.entry(server_id).or_default();
+            let preset = self
+                .profile_settings
+                .context_servers
+                .entry(server_id)
+                .or_default();
            let is_enabled = *preset.tools.entry(tool_name.clone()).or_default();
            *preset.tools.entry(tool_name.clone()).or_default() = !is_enabled;
            is_enabled
        } else {
-            let is_enabled = *self.profile.tools.entry(tool_name.clone()).or_default();
-            *self.profile.tools.entry(tool_name.clone()).or_default() = !is_enabled;
+            let is_enabled = *self
+                .profile_settings
+                .tools
+                .entry(tool_name.clone())
+                .or_default();
+            *self
+                .profile_settings
+                .tools
+                .entry(tool_name.clone())
+                .or_default() = !is_enabled;
            is_enabled
        };

-        let active_profile_id = &AgentSettings::get_global(cx).default_profile;
-        if active_profile_id == &self.profile_id {
-            self.thread_store
-                .update(cx, |this, cx| {
-                    this.load_profile(self.profile.clone(), cx);
-                })
-                .log_err();
-        }
-
        update_settings_file::<AgentSettings>(self.fs.clone(), cx, {
            let profile_id = self.profile_id.clone();
-            let default_profile = self.profile.clone();
+            let default_profile = self.profile_settings.clone();
            let server_id = server_id.clone();
            let tool_name = tool_name.clone();
            move |settings: &mut AgentSettingsContent, _cx| {
@@ -348,14 +346,18 @@ impl PickerDelegate for ToolPickerDelegate {
            ),
            PickerItem::Tool { name, server_id } => {
                let is_enabled = if let Some(server_id) = server_id {
-                    self.profile
+                    self.profile_settings
                        .context_servers
                        .get(server_id.as_ref())
                        .and_then(|preset| preset.tools.get(name))
                        .copied()
-                        .unwrap_or(self.profile.enable_all_context_servers)
+                        .unwrap_or(self.profile_settings.enable_all_context_servers)
                } else {
-                    self.profile.tools.get(name).copied().unwrap_or(false)
+                    self.profile_settings
+                        .tools
+                        .get(name)
+                        .copied()
+                        .unwrap_or(false)
                };

                Some(
--- a/crates/agent/src/agent_diff.rs
+++ b/crates/agent/src/agent_diff.rs
@@ -1378,7 +1378,8 @@ impl AgentDiff {
            | ThreadEvent::CheckpointChanged
            | ThreadEvent::ToolConfirmationNeeded
            | ThreadEvent::ToolUseLimitReached
-            | ThreadEvent::CancelEditing => {}
+            | ThreadEvent::CancelEditing
+            | ThreadEvent::ProfileChanged => {}
        }
    }

--- a/crates/agent/src/agent_model_selector.rs
+++ b/crates/agent/src/agent_model_selector.rs
@@ -91,12 +91,13 @@ impl AgentModelSelector {

 impl Render for AgentModelSelector {
    fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
-        let focus_handle = self.focus_handle.clone();
-
        let model = self.selector.read(cx).delegate.active_model(cx);
        let model_name = model
            .map(|model| model.model.name().0)
            .unwrap_or_else(|| SharedString::from("No model selected"));
+
+        let focus_handle = self.focus_handle.clone();
+
        PickerPopoverMenu::new(
            self.selector.clone(),
            Button::new("active-model", model_name)
--- a/crates/agent/src/agent_panel.rs
+++ b/crates/agent/src/agent_panel.rs
@@ -57,7 +57,7 @@ use zed_llm_client::{CompletionIntent, UsageLimit};
 use crate::active_thread::{self, ActiveThread, ActiveThreadEvent};
 use crate::agent_configuration::{AgentConfiguration, AssistantConfigurationEvent};
 use crate::agent_diff::AgentDiff;
-use crate::history_store::{HistoryStore, RecentEntry};
+use crate::history_store::{HistoryEntryId, HistoryStore};
 use crate::message_editor::{MessageEditor, MessageEditorEvent};
 use crate::thread::{Thread, ThreadError, ThreadId, ThreadSummary, TokenUsageRatio};
 use crate::thread_history::{HistoryEntryElement, ThreadHistory};
@@ -257,6 +257,7 @@ impl ActiveView {

    pub fn prompt_editor(
        context_editor: Entity<ContextEditor>,
+        history_store: Entity<HistoryStore>,
        language_registry: Arc<LanguageRegistry>,
        window: &mut Window,
        cx: &mut App,
@@ -322,6 +323,19 @@ impl ActiveView {
                            editor.set_text(summary, window, cx);
                        })
                    }
+                    ContextEvent::PathChanged { old_path, new_path } => {
+                        history_store.update(cx, |history_store, cx| {
+                            if let Some(old_path) = old_path {
+                                history_store
+                                    .replace_recently_opened_text_thread(old_path, new_path, cx);
+                            } else {
+                                history_store.push_recently_opened_entry(
+                                    HistoryEntryId::Context(new_path.clone()),
+                                    cx,
+                                );
+                            }
+                        });
+                    }
                    _ => {}
                }
            }),
@@ -516,8 +530,7 @@ impl AgentPanel {
            HistoryStore::new(
                thread_store.clone(),
                context_store.clone(),
-                [RecentEntry::Thread(thread_id, thread.clone())],
-                window,
+                [HistoryEntryId::Thread(thread_id)],
                cx,
            )
        });
@@ -544,7 +557,13 @@ impl AgentPanel {
                    editor.insert_default_prompt(window, cx);
                    editor
                });
-                ActiveView::prompt_editor(context_editor, language_registry.clone(), window, cx)
+                ActiveView::prompt_editor(
+                    context_editor,
+                    history_store.clone(),
+                    language_registry.clone(),
+                    window,
+                    cx,
+                )
            }
        };

@@ -581,86 +600,9 @@ impl AgentPanel {
            let panel = weak_panel.clone();
            let assistant_navigation_menu =
                ContextMenu::build_persistent(window, cx, move |mut menu, _window, cx| {
-                    let recently_opened = panel
-                        .update(cx, |this, cx| {
-                            this.history_store.update(cx, |history_store, cx| {
-                                history_store.recently_opened_entries(cx)
-                            })
-                        })
-                        .unwrap_or_default();
-
-                    if !recently_opened.is_empty() {
-                        menu = menu.header("Recently Opened");
-
-                        for entry in recently_opened.iter() {
-                            if let RecentEntry::Context(context) = entry {
-                                if context.read(cx).path().is_none() {
-                                    log::error!(
-                                        "bug: text thread in recent history list was never saved"
-                                    );
-                                    continue;
-                                }
-                            }
-
-                            let summary = entry.summary(cx);
-
-                            menu = menu.entry_with_end_slot_on_hover(
-                                summary,
-                                None,
-                                {
-                                    let panel = panel.clone();
-                                    let entry = entry.clone();
-                                    move |window, cx| {
-                                        panel
-                                            .update(cx, {
-                                                let entry = entry.clone();
-                                                move |this, cx| match entry {
-                                                    RecentEntry::Thread(_, thread) => {
-                                                        this.open_thread(thread, window, cx)
-                                                    }
-                                                    RecentEntry::Context(context) => {
-                                                        let Some(path) = context.read(cx).path()
-                                                        else {
-                                                            return;
-                                                        };
-                                                        this.open_saved_prompt_editor(
-                                                            path.clone(),
-                                                            window,
-                                                            cx,
-                                                        )
-                                                        .detach_and_log_err(cx)
-                                                    }
-                                                }
-                                            })
-                                            .ok();
-                                    }
-                                },
-                                IconName::Close,
-                                "Close Entry".into(),
-                                {
-                                    let panel = panel.clone();
-                                    let entry = entry.clone();
-                                    move |_window, cx| {
-                                        panel
-                                            .update(cx, |this, cx| {
-                                                this.history_store.update(
-                                                    cx,
-                                                    |history_store, cx| {
-                                                        history_store.remove_recently_opened_entry(
-                                                            &entry, cx,
-                                                        );
-                                                    },
-                                                );
-                                            })
-                                            .ok();
-                                    }
-                                },
-                            );
-                        }
-
-                        menu = menu.separator();
+                    if let Some(panel) = panel.upgrade() {
+                        menu = Self::populate_recently_opened_menu_section(menu, panel, cx);
                    }
-
                    menu.action("View All", Box::new(OpenHistory))
                        .end_slot_action(DeleteRecentlyOpenThread.boxed_clone())
                        .fixed_width(px(320.).into())
@@ -898,6 +840,7 @@ impl AgentPanel {
        self.set_active_view(
            ActiveView::prompt_editor(
                context_editor.clone(),
+                self.history_store.clone(),
                self.language_registry.clone(),
                window,
                cx,
@@ -984,7 +927,13 @@ impl AgentPanel {
            )
        });
        self.set_active_view(
-            ActiveView::prompt_editor(editor.clone(), self.language_registry.clone(), window, cx),
+            ActiveView::prompt_editor(
+                editor.clone(),
+                self.history_store.clone(),
+                self.language_registry.clone(),
+                window,
+                cx,
+            ),
            window,
            cx,
        );
@@ -1383,16 +1332,6 @@ impl AgentPanel {
                    }
                }
            }
-            ActiveView::TextThread { context_editor, .. } => {
-                let context = context_editor.read(cx).context();
-                // When switching away from an unsaved text thread, delete its entry.
-                if context.read(cx).path().is_none() {
-                    let context = context.clone();
-                    self.history_store.update(cx, |store, cx| {
-                        store.remove_recently_opened_entry(&RecentEntry::Context(context), cx);
-                    });
-                }
-            }
            _ => {}
        }

@@ -1400,13 +1339,14 @@ impl AgentPanel {
            ActiveView::Thread { thread, .. } => self.history_store.update(cx, |store, cx| {
                if let Some(thread) = thread.upgrade() {
                    let id = thread.read(cx).id().clone();
-                    store.push_recently_opened_entry(RecentEntry::Thread(id, thread), cx);
+                    store.push_recently_opened_entry(HistoryEntryId::Thread(id), cx);
                }
            }),
            ActiveView::TextThread { context_editor, .. } => {
                self.history_store.update(cx, |store, cx| {
-                    let context = context_editor.read(cx).context().clone();
-                    store.push_recently_opened_entry(RecentEntry::Context(context), cx)
+                    if let Some(path) = context_editor.read(cx).context().read(cx).path() {
+                        store.push_recently_opened_entry(HistoryEntryId::Context(path.clone()), cx)
+                    }
                })
            }
            _ => {}
@@ -1425,6 +1365,70 @@ impl AgentPanel {

        self.focus_handle(cx).focus(window);
    }
+
+    fn populate_recently_opened_menu_section(
+        mut menu: ContextMenu,
+        panel: Entity<Self>,
+        cx: &mut Context<ContextMenu>,
+    ) -> ContextMenu {
+        let entries = panel
+            .read(cx)
+            .history_store
+            .read(cx)
+            .recently_opened_entries(cx);
+
+        if entries.is_empty() {
+            return menu;
+        }
+
+        menu = menu.header("Recently Opened");
+
+        for entry in entries {
+            let title = entry.title().clone();
+            let id = entry.id();
+
+            menu = menu.entry_with_end_slot_on_hover(
+                title,
+                None,
+                {
+                    let panel = panel.downgrade();
+                    let id = id.clone();
+                    move |window, cx| {
+                        let id = id.clone();
+                        panel
+                            .update(cx, move |this, cx| match id {
+                                HistoryEntryId::Thread(id) => this
+                                    .open_thread_by_id(&id, window, cx)
+                                    .detach_and_log_err(cx),
+                                HistoryEntryId::Context(path) => this
+                                    .open_saved_prompt_editor(path.clone(), window, cx)
+                                    .detach_and_log_err(cx),
+                            })
+                            .ok();
+                    }
+                },
+                IconName::Close,
+                "Close Entry".into(),
+                {
+                    let panel = panel.downgrade();
+                    let id = id.clone();
+                    move |_window, cx| {
+                        panel
+                            .update(cx, |this, cx| {
+                                this.history_store.update(cx, |history_store, cx| {
+                                    history_store.remove_recently_opened_entry(&id, cx);
+                                });
+                            })
+                            .ok();
+                    }
+                },
+            );
+        }
+
+        menu = menu.separator();
+
+        menu
+    }
 }

 impl Focusable for AgentPanel {
--- a/crates/agent/src/agent_profile.rs
+++ b/crates/agent/src/agent_profile.rs
@@ -0,0 +1,334 @@
+use std::sync::Arc;
+
+use agent_settings::{AgentProfileId, AgentProfileSettings, AgentSettings};
+use assistant_tool::{Tool, ToolSource, ToolWorkingSet};
+use collections::IndexMap;
+use convert_case::{Case, Casing};
+use fs::Fs;
+use gpui::{App, Entity};
+use settings::{Settings, update_settings_file};
+use ui::SharedString;
+use util::ResultExt;
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct AgentProfile {
+    id: AgentProfileId,
+    tool_set: Entity<ToolWorkingSet>,
+}
+
+pub type AvailableProfiles = IndexMap<AgentProfileId, SharedString>;
+
+impl AgentProfile {
+    pub fn new(id: AgentProfileId, tool_set: Entity<ToolWorkingSet>) -> Self {
+        Self { id, tool_set }
+    }
+
+    /// Saves a new profile to the settings.
+    pub fn create(
+        name: String,
+        base_profile_id: Option<AgentProfileId>,
+        fs: Arc<dyn Fs>,
+        cx: &App,
+    ) -> AgentProfileId {
+        let id = AgentProfileId(name.to_case(Case::Kebab).into());
+
+        let base_profile =
+            base_profile_id.and_then(|id| AgentSettings::get_global(cx).profiles.get(&id).cloned());
+
+        let profile_settings = AgentProfileSettings {
+            name: name.into(),
+            tools: base_profile
+                .as_ref()
+                .map(|profile| profile.tools.clone())
+                .unwrap_or_default(),
+            enable_all_context_servers: base_profile
+                .as_ref()
+                .map(|profile| profile.enable_all_context_servers)
+                .unwrap_or_default(),
+            context_servers: base_profile
+                .map(|profile| profile.context_servers)
+                .unwrap_or_default(),
+        };
+
+        update_settings_file::<AgentSettings>(fs, cx, {
+            let id = id.clone();
+            move |settings, _cx| {
+                settings.create_profile(id, profile_settings).log_err();
+            }
+        });
+
+        id
+    }
+
+    /// Returns a map of AgentProfileIds to their names
+    pub fn available_profiles(cx: &App) -> AvailableProfiles {
+        let mut profiles = AvailableProfiles::default();
+        for (id, profile) in AgentSettings::get_global(cx).profiles.iter() {
+            profiles.insert(id.clone(), profile.name.clone());
+        }
+        profiles
+    }
+
+    pub fn id(&self) -> &AgentProfileId {
+        &self.id
+    }
+
+    pub fn enabled_tools(&self, cx: &App) -> Vec<Arc<dyn Tool>> {
+        let Some(settings) = AgentSettings::get_global(cx).profiles.get(&self.id) else {
+            return Vec::new();
+        };
+
+        self.tool_set
+            .read(cx)
+            .tools(cx)
+            .into_iter()
+            .filter(|tool| Self::is_enabled(settings, tool.source(), tool.name()))
+            .collect()
+    }
+
+    fn is_enabled(settings: &AgentProfileSettings, source: ToolSource, name: String) -> bool {
+        match source {
+            ToolSource::Native => *settings.tools.get(name.as_str()).unwrap_or(&false),
+            ToolSource::ContextServer { id } => {
+                if settings.enable_all_context_servers {
+                    return true;
+                }
+
+                let Some(preset) = settings.context_servers.get(id.as_ref()) else {
+                    return false;
+                };
+                *preset.tools.get(name.as_str()).unwrap_or(&false)
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use agent_settings::ContextServerPreset;
+    use assistant_tool::ToolRegistry;
+    use collections::IndexMap;
+    use gpui::{AppContext, TestAppContext};
+    use http_client::FakeHttpClient;
+    use project::Project;
+    use settings::{Settings, SettingsStore};
+    use ui::SharedString;
+
+    use super::*;
+
+    #[gpui::test]
+    async fn test_enabled_built_in_tools_for_profile(cx: &mut TestAppContext) {
+        init_test_settings(cx);
+
+        let id = AgentProfileId::default();
+        let profile_settings = cx.read(|cx| {
+            AgentSettings::get_global(cx)
+                .profiles
+                .get(&id)
+                .unwrap()
+                .clone()
+        });
+        let tool_set = default_tool_set(cx);
+
+        let profile = AgentProfile::new(id.clone(), tool_set);
+
+        let mut enabled_tools = cx
+            .read(|cx| profile.enabled_tools(cx))
+            .into_iter()
+            .map(|tool| tool.name())
+            .collect::<Vec<_>>();
+        enabled_tools.sort();
+
+        let mut expected_tools = profile_settings
+            .tools
+            .into_iter()
+            .filter_map(|(tool, enabled)| enabled.then_some(tool.to_string()))
+            // Provider dependent
+            .filter(|tool| tool != "web_search")
+            .collect::<Vec<_>>();
+        // Plus all registered MCP tools
+        expected_tools.extend(["enabled_mcp_tool".into(), "disabled_mcp_tool".into()]);
+        expected_tools.sort();
+
+        assert_eq!(enabled_tools, expected_tools);
+    }
+
+    #[gpui::test]
+    async fn test_custom_mcp_settings(cx: &mut TestAppContext) {
+        init_test_settings(cx);
+
+        let id = AgentProfileId("custom_mcp".into());
+        let profile_settings = cx.read(|cx| {
+            AgentSettings::get_global(cx)
+                .profiles
+                .get(&id)
+                .unwrap()
+                .clone()
+        });
+        let tool_set = default_tool_set(cx);
+
+        let profile = AgentProfile::new(id.clone(), tool_set);
+
+        let mut enabled_tools = cx
+            .read(|cx| profile.enabled_tools(cx))
+            .into_iter()
+            .map(|tool| tool.name())
+            .collect::<Vec<_>>();
+        enabled_tools.sort();
+
+        let mut expected_tools = profile_settings.context_servers["mcp"]
+            .tools
+            .iter()
+            .filter_map(|(key, enabled)| enabled.then(|| key.to_string()))
+            .collect::<Vec<_>>();
+        expected_tools.sort();
+
+        assert_eq!(enabled_tools, expected_tools);
+    }
+
+    #[gpui::test]
+    async fn test_only_built_in(cx: &mut TestAppContext) {
+        init_test_settings(cx);
+
+        let id = AgentProfileId("write_minus_mcp".into());
+        let profile_settings = cx.read(|cx| {
+            AgentSettings::get_global(cx)
+                .profiles
+                .get(&id)
+                .unwrap()
+                .clone()
+        });
+        let tool_set = default_tool_set(cx);
+
+        let profile = AgentProfile::new(id.clone(), tool_set);
+
+        let mut enabled_tools = cx
+            .read(|cx| profile.enabled_tools(cx))
+            .into_iter()
+            .map(|tool| tool.name())
+            .collect::<Vec<_>>();
+        enabled_tools.sort();
+
+        let mut expected_tools = profile_settings
+            .tools
+            .into_iter()
+            .filter_map(|(tool, enabled)| enabled.then_some(tool.to_string()))
+            // Provider dependent
+            .filter(|tool| tool != "web_search")
+            .collect::<Vec<_>>();
+        expected_tools.sort();
+
+        assert_eq!(enabled_tools, expected_tools);
+    }
+
+    fn init_test_settings(cx: &mut TestAppContext) {
+        cx.update(|cx| {
+            let settings_store = SettingsStore::test(cx);
+            cx.set_global(settings_store);
+            Project::init_settings(cx);
+            AgentSettings::register(cx);
+            language_model::init_settings(cx);
+            ToolRegistry::default_global(cx);
+            assistant_tools::init(FakeHttpClient::with_404_response(), cx);
+        });
+
+        cx.update(|cx| {
+            let mut agent_settings = AgentSettings::get_global(cx).clone();
+            agent_settings.profiles.insert(
+                AgentProfileId("write_minus_mcp".into()),
+                AgentProfileSettings {
+                    name: "write_minus_mcp".into(),
+                    enable_all_context_servers: false,
+                    ..agent_settings.profiles[&AgentProfileId::default()].clone()
+                },
+            );
+            agent_settings.profiles.insert(
+                AgentProfileId("custom_mcp".into()),
+                AgentProfileSettings {
+                    name: "mcp".into(),
+                    tools: IndexMap::default(),
+                    enable_all_context_servers: false,
+                    context_servers: IndexMap::from_iter([("mcp".into(), context_server_preset())]),
+                },
+            );
+            AgentSettings::override_global(agent_settings, cx);
+        })
+    }
+
+    fn context_server_preset() -> ContextServerPreset {
+        ContextServerPreset {
+            tools: IndexMap::from_iter([
+                ("enabled_mcp_tool".into(), true),
+                ("disabled_mcp_tool".into(), false),
+            ]),
+        }
+    }
+
+    fn default_tool_set(cx: &mut TestAppContext) -> Entity<ToolWorkingSet> {
+        cx.new(|_| {
+            let mut tool_set = ToolWorkingSet::default();
+            tool_set.insert(Arc::new(FakeTool::new("enabled_mcp_tool", "mcp")));
+            tool_set.insert(Arc::new(FakeTool::new("disabled_mcp_tool", "mcp")));
+            tool_set
+        })
+    }
+
+    struct FakeTool {
+        name: String,
+        source: SharedString,
+    }
+
+    impl FakeTool {
+        fn new(name: impl Into<String>, source: impl Into<SharedString>) -> Self {
+            Self {
+                name: name.into(),
+                source: source.into(),
+            }
+        }
+    }
+
+    impl Tool for FakeTool {
+        fn name(&self) -> String {
+            self.name.clone()
+        }
+
+        fn source(&self) -> ToolSource {
+            ToolSource::ContextServer {
+                id: self.source.clone(),
+            }
+        }
+
+        fn description(&self) -> String {
+            unimplemented!()
+        }
+
+        fn icon(&self) -> ui::IconName {
+            unimplemented!()
+        }
+
+        fn needs_confirmation(&self, _input: &serde_json::Value, _cx: &App) -> bool {
+            unimplemented!()
+        }
+
+        fn ui_text(&self, _input: &serde_json::Value) -> String {
+            unimplemented!()
+        }
+
+        fn run(
+            self: Arc<Self>,
+            _input: serde_json::Value,
+            _request: Arc<language_model::LanguageModelRequest>,
+            _project: Entity<Project>,
+            _action_log: Entity<assistant_tool::ActionLog>,
+            _model: Arc<dyn language_model::LanguageModel>,
+            _window: Option<gpui::AnyWindowHandle>,
+            _cx: &mut App,
+        ) -> assistant_tool::ToolResult {
+            unimplemented!()
+        }
+
+        fn may_perform_edits(&self) -> bool {
+            unimplemented!()
+        }
+    }
+}
--- a/crates/agent/src/buffer_codegen.rs
+++ b/crates/agent/src/buffer_codegen.rs
@@ -386,8 +386,10 @@ impl CodegenAlternative {
                async { Ok(LanguageModelTextStream::default()) }.boxed_local()
            } else {
                let request = self.build_request(&model, user_prompt, cx)?;
-                cx.spawn(async move |_, cx| model.stream_completion_text(request.await, &cx).await)
-                    .boxed_local()
+                cx.spawn(async move |_, cx| {
+                    Ok(model.stream_completion_text(request.await, &cx).await?)
+                })
+                .boxed_local()
            };
        self.handle_stream(telemetry_id, provider_id.to_string(), api_key, stream, cx);
        Ok(())
--- a/crates/agent/src/context_picker/completion_provider.rs
+++ b/crates/agent/src/context_picker/completion_provider.rs
@@ -1,7 +1,5 @@
-use std::cell::RefCell;
 use std::ops::Range;
 use std::path::{Path, PathBuf};
-use std::rc::Rc;
 use std::sync::Arc;
 use std::sync::atomic::AtomicBool;

@@ -767,7 +765,7 @@ impl CompletionProvider for ContextPickerCompletionProvider {

        let snapshot = buffer.read(cx).snapshot();
        let source_range = snapshot.anchor_before(state.source_range.start)
-            ..snapshot.anchor_before(state.source_range.end);
+            ..snapshot.anchor_after(state.source_range.end);

        let thread_store = self.thread_store.clone();
        let text_thread_store = self.text_thread_store.clone();
@@ -912,16 +910,6 @@ impl CompletionProvider for ContextPickerCompletionProvider {
        })
    }

-    fn resolve_completions(
-        &self,
-        _buffer: Entity<Buffer>,
-        _completion_indices: Vec<usize>,
-        _completions: Rc<RefCell<Box<[Completion]>>>,
-        _cx: &mut Context<Editor>,
-    ) -> Task<Result<bool>> {
-        Task::ready(Ok(true))
-    }
-
    fn is_completion_trigger(
        &self,
        buffer: &Entity<language::Buffer>,
@@ -1077,7 +1065,7 @@ mod tests {
    use project::{Project, ProjectPath};
    use serde_json::json;
    use settings::SettingsStore;
-    use std::ops::Deref;
+    use std::{ops::Deref, rc::Rc};
    use util::{path, separator};
    use workspace::{AppState, Item};

--- a/crates/agent/src/context_picker/thread_context_picker.rs
+++ b/crates/agent/src/context_picker/thread_context_picker.rs
@@ -282,15 +282,18 @@ pub fn unordered_thread_entries(
    text_thread_store: Entity<TextThreadStore>,
    cx: &App,
 ) -> impl Iterator<Item = (DateTime<Utc>, ThreadContextEntry)> {
-    let threads = thread_store.read(cx).unordered_threads().map(|thread| {
-        (
-            thread.updated_at,
-            ThreadContextEntry::Thread {
-                id: thread.id.clone(),
-                title: thread.summary.clone(),
-            },
-        )
-    });
+    let threads = thread_store
+        .read(cx)
+        .reverse_chronological_threads()
+        .map(|thread| {
+            (
+                thread.updated_at,
+                ThreadContextEntry::Thread {
+                    id: thread.id.clone(),
+                    title: thread.summary.clone(),
+                },
+            )
+        });

    let text_threads = text_thread_store
        .read(cx)
@@ -300,7 +303,7 @@ pub fn unordered_thread_entries(
                context.mtime.to_utc(),
                ThreadContextEntry::Context {
                    path: context.path.clone(),
-                    title: context.title.clone().into(),
+                    title: context.title.clone(),
                },
            )
        });
--- a/crates/agent/src/context_server_configuration.rs
+++ b/crates/agent/src/context_server_configuration.rs
@@ -71,6 +71,10 @@ fn show_configure_mcp_modal(
    window: &mut Window,
    cx: &mut Context<'_, Workspace>,
 ) {
+    if !window.is_window_active() {
+        return;
+    }
+
    let context_server_store = workspace.project().read(cx).context_server_store();
    let repository: Option<SharedString> = manifest.repository.as_ref().map(|s| s.clone().into());

--- a/crates/agent/src/context_server_tool.rs
+++ b/crates/agent/src/context_server_tool.rs
@@ -104,7 +104,15 @@ impl Tool for ContextServerTool {
                    tool_name,
                    arguments
                );
-                let response = protocol.run_tool(tool_name, arguments).await?;
+                let response = protocol
+                    .request::<context_server::types::requests::CallTool>(
+                        context_server::types::CallToolParams {
+                            name: tool_name,
+                            arguments,
+                            meta: None,
+                        },
+                    )
+                    .await?;

                let mut result = String::new();
                for content in response.content {
@@ -115,6 +123,9 @@ impl Tool for ContextServerTool {
                        types::ToolResponseContent::Image { .. } => {
                            log::warn!("Ignoring image content from tool response");
                        }
+                        types::ToolResponseContent::Audio { .. } => {
+                            log::warn!("Ignoring audio content from tool response");
+                        }
                        types::ToolResponseContent::Resource { .. } => {
                            log::warn!("Ignoring resource content from tool response");
                        }
--- a/crates/agent/src/history_store.rs
+++ b/crates/agent/src/history_store.rs
@@ -1,18 +1,17 @@
 use std::{collections::VecDeque, path::Path, sync::Arc};

-use anyhow::Context as _;
-use assistant_context_editor::{AssistantContext, SavedContextMetadata};
+use anyhow::{Context as _, Result};
+use assistant_context_editor::SavedContextMetadata;
 use chrono::{DateTime, Utc};
-use futures::future::{TryFutureExt as _, join_all};
-use gpui::{Entity, Task, prelude::*};
+use gpui::{AsyncApp, Entity, SharedString, Task, prelude::*};
+use itertools::Itertools;
+use paths::contexts_dir;
 use serde::{Deserialize, Serialize};
-use smol::future::FutureExt;
 use std::time::Duration;
-use ui::{App, SharedString, Window};
+use ui::App;
 use util::ResultExt as _;

 use crate::{
-    Thread,
    thread::ThreadId,
    thread_store::{SerializedThreadMetadata, ThreadStore},
 };
@@ -41,52 +40,34 @@ impl HistoryEntry {
            HistoryEntry::Context(context) => HistoryEntryId::Context(context.path.clone()),
        }
    }
+
+    pub fn title(&self) -> &SharedString {
+        match self {
+            HistoryEntry::Thread(thread) => &thread.summary,
+            HistoryEntry::Context(context) => &context.title,
+        }
+    }
 }

 /// Generic identifier for a history entry.
-#[derive(Clone, PartialEq, Eq)]
+#[derive(Clone, PartialEq, Eq, Debug)]
 pub enum HistoryEntryId {
    Thread(ThreadId),
    Context(Arc<Path>),
 }

-#[derive(Clone, Debug)]
-pub(crate) enum RecentEntry {
-    Thread(ThreadId, Entity<Thread>),
-    Context(Entity<AssistantContext>),
-}
-
-impl PartialEq for RecentEntry {
-    fn eq(&self, other: &Self) -> bool {
-        match (self, other) {
-            (Self::Thread(l0, _), Self::Thread(r0, _)) => l0 == r0,
-            (Self::Context(l0), Self::Context(r0)) => l0 == r0,
-            _ => false,
-        }
-    }
-}
-
-impl Eq for RecentEntry {}
-
-impl RecentEntry {
-    pub(crate) fn summary(&self, cx: &App) -> SharedString {
-        match self {
-            RecentEntry::Thread(_, thread) => thread.read(cx).summary().or_default(),
-            RecentEntry::Context(context) => context.read(cx).summary().or_default(),
-        }
-    }
-}
-
 #[derive(Serialize, Deserialize)]
-enum SerializedRecentEntry {
+enum SerializedRecentOpen {
    Thread(String),
+    ContextName(String),
+    /// Old format which stores the full path
    Context(String),
 }

 pub struct HistoryStore {
    thread_store: Entity<ThreadStore>,
    context_store: Entity<assistant_context_editor::ContextStore>,
-    recently_opened_entries: VecDeque<RecentEntry>,
+    recently_opened_entries: VecDeque<HistoryEntryId>,
    _subscriptions: Vec<gpui::Subscription>,
    _save_recently_opened_entries_task: Task<()>,
 }
@@ -95,8 +76,7 @@ impl HistoryStore {
    pub fn new(
        thread_store: Entity<ThreadStore>,
        context_store: Entity<assistant_context_editor::ContextStore>,
-        initial_recent_entries: impl IntoIterator<Item = RecentEntry>,
-        window: &mut Window,
+        initial_recent_entries: impl IntoIterator<Item = HistoryEntryId>,
        cx: &mut Context<Self>,
    ) -> Self {
        let subscriptions = vec![
@@ -104,68 +84,20 @@ impl HistoryStore {
            cx.observe(&context_store, |_, _, cx| cx.notify()),
        ];

-        window
-            .spawn(cx, {
-                let thread_store = thread_store.downgrade();
-                let context_store = context_store.downgrade();
-                let this = cx.weak_entity();
-                async move |cx| {
-                    let path = paths::data_dir().join(NAVIGATION_HISTORY_PATH);
-                    let contents = cx
-                        .background_spawn(async move { std::fs::read_to_string(path) })
-                        .await
-                        .ok()?;
-                    let entries = serde_json::from_str::<Vec<SerializedRecentEntry>>(&contents)
-                        .context("deserializing persisted agent panel navigation history")
-                        .log_err()?
-                        .into_iter()
-                        .take(MAX_RECENTLY_OPENED_ENTRIES)
-                        .map(|serialized| match serialized {
-                            SerializedRecentEntry::Thread(id) => thread_store
-                                .update_in(cx, |thread_store, window, cx| {
-                                    let thread_id = ThreadId::from(id.as_str());
-                                    thread_store
-                                        .open_thread(&thread_id, window, cx)
-                                        .map_ok(|thread| RecentEntry::Thread(thread_id, thread))
-                                        .boxed()
-                                })
-                                .unwrap_or_else(|_| {
-                                    async {
-                                        anyhow::bail!("no thread store");
-                                    }
-                                    .boxed()
-                                }),
-                            SerializedRecentEntry::Context(id) => context_store
-                                .update(cx, |context_store, cx| {
-                                    context_store
-                                        .open_local_context(Path::new(&id).into(), cx)
-                                        .map_ok(RecentEntry::Context)
-                                        .boxed()
-                                })
-                                .unwrap_or_else(|_| {
-                                    async {
-                                        anyhow::bail!("no context store");
-                                    }
-                                    .boxed()
-                                }),
-                        });
-                    let entries = join_all(entries)
-                        .await
-                        .into_iter()
-                        .filter_map(|result| result.log_with_level(log::Level::Debug))
-                        .collect::<VecDeque<_>>();
-
-                    this.update(cx, |this, _| {
-                        this.recently_opened_entries.extend(entries);
-                        this.recently_opened_entries
-                            .truncate(MAX_RECENTLY_OPENED_ENTRIES);
-                    })
-                    .ok();
-
-                    Some(())
-                }
+        cx.spawn(async move |this, cx| {
+            let entries = Self::load_recently_opened_entries(cx).await.log_err()?;
+            this.update(cx, |this, _| {
+                this.recently_opened_entries
+                    .extend(
+                        entries.into_iter().take(
+                            MAX_RECENTLY_OPENED_ENTRIES
+                                .saturating_sub(this.recently_opened_entries.len()),
+                        ),
+                    );
            })
-            .detach();
+            .ok()
+        })
+        .detach();

        Self {
            thread_store,
@@ -184,19 +116,20 @@ impl HistoryStore {
            return history_entries;
        }

-        for thread in self
-            .thread_store
-            .update(cx, |this, _cx| this.reverse_chronological_threads())
-        {
-            history_entries.push(HistoryEntry::Thread(thread));
-        }
-
-        for context in self
-            .context_store
-            .update(cx, |this, _cx| this.reverse_chronological_contexts())
-        {
-            history_entries.push(HistoryEntry::Context(context));
-        }
+        history_entries.extend(
+            self.thread_store
+                .read(cx)
+                .reverse_chronological_threads()
+                .cloned()
+                .map(HistoryEntry::Thread),
+        );
+        history_entries.extend(
+            self.context_store
+                .read(cx)
+                .unordered_contexts()
+                .cloned()
+                .map(HistoryEntry::Context),
+        );

        history_entries.sort_unstable_by_key(|entry| std::cmp::Reverse(entry.updated_at()));
        history_entries
@@ -206,15 +139,62 @@ impl HistoryStore {
        self.entries(cx).into_iter().take(limit).collect()
    }

+    pub fn recently_opened_entries(&self, cx: &App) -> Vec<HistoryEntry> {
+        #[cfg(debug_assertions)]
+        if std::env::var("ZED_SIMULATE_NO_THREAD_HISTORY").is_ok() {
+            return Vec::new();
+        }
+
+        let thread_entries = self
+            .thread_store
+            .read(cx)
+            .reverse_chronological_threads()
+            .flat_map(|thread| {
+                self.recently_opened_entries
+                    .iter()
+                    .enumerate()
+                    .flat_map(|(index, entry)| match entry {
+                        HistoryEntryId::Thread(id) if &thread.id == id => {
+                            Some((index, HistoryEntry::Thread(thread.clone())))
+                        }
+                        _ => None,
+                    })
+            });
+
+        let context_entries =
+            self.context_store
+                .read(cx)
+                .unordered_contexts()
+                .flat_map(|context| {
+                    self.recently_opened_entries
+                        .iter()
+                        .enumerate()
+                        .flat_map(|(index, entry)| match entry {
+                            HistoryEntryId::Context(path) if &context.path == path => {
+                                Some((index, HistoryEntry::Context(context.clone())))
+                            }
+                            _ => None,
+                        })
+                });
+
+        thread_entries
+            .chain(context_entries)
+            // optimization to halt iteration early
+            .take(self.recently_opened_entries.len())
+            .sorted_unstable_by_key(|(index, _)| *index)
+            .map(|(_, entry)| entry)
+            .collect()
+    }
+
    fn save_recently_opened_entries(&mut self, cx: &mut Context<Self>) {
        let serialized_entries = self
            .recently_opened_entries
            .iter()
            .filter_map(|entry| match entry {
-                RecentEntry::Context(context) => Some(SerializedRecentEntry::Context(
-                    context.read(cx).path()?.to_str()?.to_owned(),
-                )),
-                RecentEntry::Thread(id, _) => Some(SerializedRecentEntry::Thread(id.to_string())),
+                HistoryEntryId::Context(path) => path.file_name().map(|file| {
+                    SerializedRecentOpen::ContextName(file.to_string_lossy().to_string())
+                }),
+                HistoryEntryId::Thread(id) => Some(SerializedRecentOpen::Thread(id.to_string())),
            })
            .collect::<Vec<_>>();

@@ -233,7 +213,33 @@ impl HistoryStore {
        });
    }

-    pub fn push_recently_opened_entry(&mut self, entry: RecentEntry, cx: &mut Context<Self>) {
+    fn load_recently_opened_entries(cx: &AsyncApp) -> Task<Result<Vec<HistoryEntryId>>> {
+        cx.background_spawn(async move {
+            let path = paths::data_dir().join(NAVIGATION_HISTORY_PATH);
+            let contents = smol::fs::read_to_string(path).await?;
+            let entries = serde_json::from_str::<Vec<SerializedRecentOpen>>(&contents)
+                .context("deserializing persisted agent panel navigation history")?
+                .into_iter()
+                .take(MAX_RECENTLY_OPENED_ENTRIES)
+                .flat_map(|entry| match entry {
+                    SerializedRecentOpen::Thread(id) => {
+                        Some(HistoryEntryId::Thread(id.as_str().into()))
+                    }
+                    SerializedRecentOpen::ContextName(file_name) => Some(HistoryEntryId::Context(
+                        contexts_dir().join(file_name).into(),
+                    )),
+                    SerializedRecentOpen::Context(path) => {
+                        Path::new(&path).file_name().map(|file_name| {
+                            HistoryEntryId::Context(contexts_dir().join(file_name).into())
+                        })
+                    }
+                })
+                .collect::<Vec<_>>();
+            Ok(entries)
+        })
+    }
+
+    pub fn push_recently_opened_entry(&mut self, entry: HistoryEntryId, cx: &mut Context<Self>) {
        self.recently_opened_entries
            .retain(|old_entry| old_entry != &entry);
        self.recently_opened_entries.push_front(entry);
@@ -244,24 +250,33 @@ impl HistoryStore {

    pub fn remove_recently_opened_thread(&mut self, id: ThreadId, cx: &mut Context<Self>) {
        self.recently_opened_entries.retain(|entry| match entry {
-            RecentEntry::Thread(thread_id, _) if thread_id == &id => false,
+            HistoryEntryId::Thread(thread_id) if thread_id == &id => false,
            _ => true,
        });
        self.save_recently_opened_entries(cx);
    }

-    pub fn remove_recently_opened_entry(&mut self, entry: &RecentEntry, cx: &mut Context<Self>) {
+    pub fn replace_recently_opened_text_thread(
+        &mut self,
+        old_path: &Path,
+        new_path: &Arc<Path>,
+        cx: &mut Context<Self>,
+    ) {
+        for entry in &mut self.recently_opened_entries {
+            match entry {
+                HistoryEntryId::Context(path) if path.as_ref() == old_path => {
+                    *entry = HistoryEntryId::Context(new_path.clone());
+                    break;
+                }
+                _ => {}
+            }
+        }
+        self.save_recently_opened_entries(cx);
+    }
+
+    pub fn remove_recently_opened_entry(&mut self, entry: &HistoryEntryId, cx: &mut Context<Self>) {
        self.recently_opened_entries
            .retain(|old_entry| old_entry != entry);
        self.save_recently_opened_entries(cx);
    }
-
-    pub fn recently_opened_entries(&self, _cx: &mut Context<Self>) -> VecDeque<RecentEntry> {
-        #[cfg(debug_assertions)]
-        if std::env::var("ZED_SIMULATE_NO_THREAD_HISTORY").is_ok() {
-            return VecDeque::new();
-        }
-
-        self.recently_opened_entries.clone()
-    }
 }
--- a/crates/agent/src/inline_assistant.rs
+++ b/crates/agent/src/inline_assistant.rs
@@ -38,8 +38,7 @@ use telemetry_events::{AssistantEventData, AssistantKind, AssistantPhase};
 use terminal_view::{TerminalView, terminal_panel::TerminalPanel};
 use text::{OffsetRangeExt, ToPoint as _};
 use ui::prelude::*;
-use util::RangeExt;
-use util::ResultExt;
+use util::{RangeExt, ResultExt, maybe};
 use workspace::{ItemHandle, Toast, Workspace, dock::Panel, notifications::NotificationId};
 use zed_actions::agent::OpenConfiguration;

@@ -1011,7 +1010,7 @@ impl InlineAssistant {
                        self.update_editor_highlights(&editor, cx);
                    }
                } else {
-                    entry.get().highlight_updates.send(()).ok();
+                    entry.get_mut().highlight_updates.send(()).ok();
                }
            }

@@ -1171,27 +1170,31 @@ impl InlineAssistant {
                selections.select_anchor_ranges([position..position])
            });

-            let mut scroll_target_top;
-            let mut scroll_target_bottom;
+            let mut scroll_target_range = None;
            if let Some(decorations) = assist.decorations.as_ref() {
-                scroll_target_top = editor
-                    .row_for_block(decorations.prompt_block_id, cx)
-                    .unwrap()
-                    .0 as f32;
-                scroll_target_bottom = editor
-                    .row_for_block(decorations.end_block_id, cx)
-                    .unwrap()
-                    .0 as f32;
-            } else {
+                scroll_target_range = maybe!({
+                    let top = editor.row_for_block(decorations.prompt_block_id, cx)?.0 as f32;
+                    let bottom = editor.row_for_block(decorations.end_block_id, cx)?.0 as f32;
+                    Some((top, bottom))
+                });
+                if scroll_target_range.is_none() {
+                    log::error!("bug: failed to find blocks for scrolling to inline assist");
+                }
+            }
+            let scroll_target_range = scroll_target_range.unwrap_or_else(|| {
                let snapshot = editor.snapshot(window, cx);
                let start_row = assist
                    .range
                    .start
                    .to_display_point(&snapshot.display_snapshot)
                    .row();
-                scroll_target_top = start_row.0 as f32;
-                scroll_target_bottom = scroll_target_top + 1.;
-            }
+                let top = start_row.0 as f32;
+                let bottom = top + 1.0;
+                (top, bottom)
+            });
+            let mut scroll_target_top = scroll_target_range.0;
+            let mut scroll_target_bottom = scroll_target_range.1;
+
            scroll_target_top -= editor.vertical_scroll_margin() as f32;
            scroll_target_bottom += editor.vertical_scroll_margin() as f32;

@@ -1331,7 +1334,7 @@ impl InlineAssistant {
                editor.clear_gutter_highlights::<GutterPendingRange>(cx);
            } else {
                editor.highlight_gutter::<GutterPendingRange>(
-                    &gutter_pending_ranges,
+                    gutter_pending_ranges,
                    |cx| cx.theme().status().info_background,
                    cx,
                )
@@ -1342,7 +1345,7 @@ impl InlineAssistant {
                editor.clear_gutter_highlights::<GutterTransformedRange>(cx);
            } else {
                editor.highlight_gutter::<GutterTransformedRange>(
-                    &gutter_transformed_ranges,
+                    gutter_transformed_ranges,
                    |cx| cx.theme().status().info,
                    cx,
                )
@@ -1519,7 +1522,7 @@ impl InlineAssistant {
 struct EditorInlineAssists {
    assist_ids: Vec<InlineAssistId>,
    scroll_lock: Option<InlineAssistScrollLock>,
-    highlight_updates: async_watch::Sender<()>,
+    highlight_updates: watch::Sender<()>,
    _update_highlights: Task<Result<()>>,
    _subscriptions: Vec<gpui::Subscription>,
 }
@@ -1531,7 +1534,7 @@ struct InlineAssistScrollLock {

 impl EditorInlineAssists {
    fn new(editor: &Entity<Editor>, window: &mut Window, cx: &mut App) -> Self {
-        let (highlight_updates_tx, mut highlight_updates_rx) = async_watch::channel(());
+        let (highlight_updates_tx, mut highlight_updates_rx) = watch::channel(());
        Self {
            assist_ids: Vec::new(),
            scroll_lock: None,
@@ -1689,7 +1692,7 @@ impl InlineAssist {
                        if let Some(editor) = editor.upgrade() {
                            InlineAssistant::update_global(cx, |this, cx| {
                                if let Some(editor_assists) =
-                                    this.assists_by_editor.get(&editor.downgrade())
+                                    this.assists_by_editor.get_mut(&editor.downgrade())
                                {
                                    editor_assists.highlight_updates.send(()).ok();
                                }
--- a/crates/agent/src/message_editor.rs
+++ b/crates/agent/src/message_editor.rs
@@ -175,8 +175,7 @@ impl MessageEditor {
            )
        });

-        let incompatible_tools =
-            cx.new(|cx| IncompatibleToolsState::new(thread.read(cx).tools().clone(), cx));
+        let incompatible_tools = cx.new(|cx| IncompatibleToolsState::new(thread.clone(), cx));

        let subscriptions = vec![
            cx.subscribe_in(&context_strip, window, Self::handle_context_strip_event),
@@ -204,15 +203,8 @@ impl MessageEditor {
            )
        });

-        let profile_selector = cx.new(|cx| {
-            ProfileSelector::new(
-                fs,
-                thread.clone(),
-                thread_store,
-                editor.focus_handle(cx),
-                cx,
-            )
-        });
+        let profile_selector =
+            cx.new(|cx| ProfileSelector::new(fs, thread.clone(), editor.focus_handle(cx), cx));

        Self {
            editor: editor.clone(),
@@ -730,6 +722,7 @@ impl MessageEditor {
                    .child(
                        h_flex()
                            .flex_none()
+                            .flex_wrap()
                            .justify_between()
                            .child(
                                h_flex()
@@ -739,6 +732,7 @@ impl MessageEditor {
                            .child(
                                h_flex()
                                    .gap_1()
+                                    .flex_wrap()
                                    .when(!incompatible_tools.is_empty(), |this| {
                                        this.child(
                                            IconButton::new(
--- a/crates/agent/src/profile_selector.rs
+++ b/crates/agent/src/profile_selector.rs
@@ -1,26 +1,24 @@
 use std::sync::Arc;

-use agent_settings::{
-    AgentDockPosition, AgentProfile, AgentProfileId, AgentSettings, GroupedAgentProfiles,
-    builtin_profiles,
-};
+use agent_settings::{AgentDockPosition, AgentProfileId, AgentSettings, builtin_profiles};
 use fs::Fs;
-use gpui::{Action, Empty, Entity, FocusHandle, Subscription, WeakEntity, prelude::*};
+use gpui::{Action, Empty, Entity, FocusHandle, Subscription, prelude::*};
 use language_model::LanguageModelRegistry;
 use settings::{Settings as _, SettingsStore, update_settings_file};
 use ui::{
    ContextMenu, ContextMenuEntry, DocumentationSide, PopoverMenu, PopoverMenuHandle, Tooltip,
    prelude::*,
 };
-use util::ResultExt as _;

-use crate::{ManageProfiles, Thread, ThreadStore, ToggleProfileSelector};
+use crate::{
+    ManageProfiles, Thread, ToggleProfileSelector,
+    agent_profile::{AgentProfile, AvailableProfiles},
+};

 pub struct ProfileSelector {
-    profiles: GroupedAgentProfiles,
+    profiles: AvailableProfiles,
    fs: Arc<dyn Fs>,
    thread: Entity<Thread>,
-    thread_store: WeakEntity<ThreadStore>,
    menu_handle: PopoverMenuHandle<ContextMenu>,
    focus_handle: FocusHandle,
    _subscriptions: Vec<Subscription>,
@@ -30,7 +28,6 @@ impl ProfileSelector {
    pub fn new(
        fs: Arc<dyn Fs>,
        thread: Entity<Thread>,
-        thread_store: WeakEntity<ThreadStore>,
        focus_handle: FocusHandle,
        cx: &mut Context<Self>,
    ) -> Self {
@@ -39,10 +36,9 @@ impl ProfileSelector {
        });

        Self {
-            profiles: GroupedAgentProfiles::from_settings(AgentSettings::get_global(cx)),
+            profiles: AgentProfile::available_profiles(cx),
            fs,
            thread,
-            thread_store,
            menu_handle: PopoverMenuHandle::default(),
            focus_handle,
            _subscriptions: vec![settings_subscription],
@@ -54,7 +50,7 @@ impl ProfileSelector {
    }

    fn refresh_profiles(&mut self, cx: &mut Context<Self>) {
-        self.profiles = GroupedAgentProfiles::from_settings(AgentSettings::get_global(cx));
+        self.profiles = AgentProfile::available_profiles(cx);
    }

    fn build_context_menu(
@@ -64,21 +60,30 @@ impl ProfileSelector {
    ) -> Entity<ContextMenu> {
        ContextMenu::build(window, cx, |mut menu, _window, cx| {
            let settings = AgentSettings::get_global(cx);
-            for (profile_id, profile) in self.profiles.builtin.iter() {
+
+            let mut found_non_builtin = false;
+            for (profile_id, profile_name) in self.profiles.iter() {
+                if !builtin_profiles::is_builtin(profile_id) {
+                    found_non_builtin = true;
+                    continue;
+                }
                menu = menu.item(self.menu_entry_for_profile(
                    profile_id.clone(),
-                    profile,
+                    profile_name,
                    settings,
                    cx,
                ));
            }

-            if !self.profiles.custom.is_empty() {
+            if found_non_builtin {
                menu = menu.separator().header("Custom Profiles");
-                for (profile_id, profile) in self.profiles.custom.iter() {
+                for (profile_id, profile_name) in self.profiles.iter() {
+                    if builtin_profiles::is_builtin(profile_id) {
+                        continue;
+                    }
                    menu = menu.item(self.menu_entry_for_profile(
                        profile_id.clone(),
-                        profile,
+                        profile_name,
                        settings,
                        cx,
                    ));
@@ -99,19 +104,20 @@ impl ProfileSelector {
    fn menu_entry_for_profile(
        &self,
        profile_id: AgentProfileId,
-        profile: &AgentProfile,
+        profile_name: &SharedString,
        settings: &AgentSettings,
-        _cx: &App,
+        cx: &App,
    ) -> ContextMenuEntry {
-        let documentation = match profile.name.to_lowercase().as_str() {
+        let documentation = match profile_name.to_lowercase().as_str() {
            builtin_profiles::WRITE => Some("Get help to write anything."),
            builtin_profiles::ASK => Some("Chat about your codebase."),
            builtin_profiles::MINIMAL => Some("Chat about anything with no tools."),
            _ => None,
        };
+        let thread_profile_id = self.thread.read(cx).profile().id();

-        let entry = ContextMenuEntry::new(profile.name.clone())
-            .toggleable(IconPosition::End, profile_id == settings.default_profile);
+        let entry = ContextMenuEntry::new(profile_name.clone())
+            .toggleable(IconPosition::End, &profile_id == thread_profile_id);

        let entry = if let Some(doc_text) = documentation {
            entry.documentation_aside(documentation_side(settings.dock), move |_| {
@@ -123,7 +129,7 @@ impl ProfileSelector {

        entry.handler({
            let fs = self.fs.clone();
-            let thread_store = self.thread_store.clone();
+            let thread = self.thread.clone();
            let profile_id = profile_id.clone();
            move |_window, cx| {
                update_settings_file::<AgentSettings>(fs.clone(), cx, {
@@ -133,11 +139,9 @@ impl ProfileSelector {
                    }
                });

-                thread_store
-                    .update(cx, |this, cx| {
-                        this.load_profile_by_id(profile_id.clone(), cx);
-                    })
-                    .log_err();
+                thread.update(cx, |this, cx| {
+                    this.set_profile(profile_id.clone(), cx);
+                });
            }
        })
    }
@@ -146,7 +150,7 @@ impl ProfileSelector {
 impl Render for ProfileSelector {
    fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
        let settings = AgentSettings::get_global(cx);
-        let profile_id = &settings.default_profile;
+        let profile_id = self.thread.read(cx).profile().id();
        let profile = settings.profiles.get(profile_id);

        let selected_profile = profile
--- a/crates/agent/src/thread.rs
+++ b/crates/agent/src/thread.rs
@@ -4,7 +4,7 @@ use std::ops::Range;
 use std::sync::Arc;
 use std::time::Instant;

-use agent_settings::{AgentSettings, CompletionMode};
+use agent_settings::{AgentProfileId, AgentSettings, CompletionMode};
 use anyhow::{Result, anyhow};
 use assistant_tool::{ActionLog, AnyToolCard, Tool, ToolWorkingSet};
 use chrono::{DateTime, Utc};
@@ -41,6 +41,7 @@ use uuid::Uuid;
 use zed_llm_client::{CompletionIntent, CompletionRequestStatus};

 use crate::ThreadStore;
+use crate::agent_profile::AgentProfile;
 use crate::context::{AgentContext, AgentContextHandle, ContextLoadResult, LoadedContext};
 use crate::thread_store::{
    SerializedCrease, SerializedLanguageModel, SerializedMessage, SerializedMessageSegment,
@@ -194,20 +195,20 @@ impl MessageSegment {
    }
 }

-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 pub struct ProjectSnapshot {
    pub worktree_snapshots: Vec<WorktreeSnapshot>,
    pub unsaved_buffer_paths: Vec<String>,
    pub timestamp: DateTime<Utc>,
 }

-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 pub struct WorktreeSnapshot {
    pub worktree_path: String,
    pub git_state: Option<GitState>,
 }

-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 pub struct GitState {
    pub remote_url: Option<String>,
    pub head_sha: Option<String>,
@@ -246,7 +247,7 @@ impl LastRestoreCheckpoint {
    }
 }

-#[derive(Clone, Debug, Default, Serialize, Deserialize)]
+#[derive(Clone, Debug, Default, Serialize, Deserialize, PartialEq)]
 pub enum DetailedSummaryState {
    #[default]
    NotGenerated,
@@ -360,6 +361,7 @@ pub struct Thread {
    >,
    remaining_turns: u32,
    configured_model: Option<ConfiguredModel>,
+    profile: AgentProfile,
 }

 #[derive(Clone, Debug, PartialEq, Eq)]
@@ -389,7 +391,7 @@ impl ThreadSummary {
    }
 }

-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 pub struct ExceededWindowError {
    /// Model used when last message exceeded context window
    model_id: LanguageModelId,
@@ -407,6 +409,7 @@ impl Thread {
    ) -> Self {
        let (detailed_summary_tx, detailed_summary_rx) = postage::watch::channel();
        let configured_model = LanguageModelRegistry::read_global(cx).default_model();
+        let profile_id = AgentSettings::get_global(cx).default_profile.clone();

        Self {
            id: ThreadId::new(),
@@ -449,6 +452,7 @@ impl Thread {
            request_callback: None,
            remaining_turns: u32::MAX,
            configured_model,
+            profile: AgentProfile::new(profile_id, tools),
        }
    }

@@ -495,6 +499,9 @@ impl Thread {
        let completion_mode = serialized
            .completion_mode
            .unwrap_or_else(|| AgentSettings::get_global(cx).preferred_completion_mode);
+        let profile_id = serialized
+            .profile
+            .unwrap_or_else(|| AgentSettings::get_global(cx).default_profile.clone());

        Self {
            id,
@@ -554,7 +561,7 @@ impl Thread {
            pending_checkpoint: None,
            project: project.clone(),
            prompt_builder,
-            tools,
+            tools: tools.clone(),
            tool_use,
            action_log: cx.new(|_| ActionLog::new(project)),
            initial_project_snapshot: Task::ready(serialized.initial_project_snapshot).shared(),
@@ -570,6 +577,7 @@ impl Thread {
            request_callback: None,
            remaining_turns: u32::MAX,
            configured_model,
+            profile: AgentProfile::new(profile_id, tools),
        }
    }

@@ -585,6 +593,17 @@ impl Thread {
        &self.id
    }

+    pub fn profile(&self) -> &AgentProfile {
+        &self.profile
+    }
+
+    pub fn set_profile(&mut self, id: AgentProfileId, cx: &mut Context<Self>) {
+        if &id != self.profile.id() {
+            self.profile = AgentProfile::new(id, self.tools.clone());
+            cx.emit(ThreadEvent::ProfileChanged);
+        }
+    }
+
    pub fn is_empty(&self) -> bool {
        self.messages.is_empty()
    }
@@ -919,8 +938,7 @@ impl Thread {
        model: Arc<dyn LanguageModel>,
    ) -> Vec<LanguageModelRequestTool> {
        if model.supports_tools() {
-            self.tools()
-                .read(cx)
+            self.profile
                .enabled_tools(cx)
                .into_iter()
                .filter_map(|tool| {
@@ -1180,6 +1198,7 @@ impl Thread {
                    }),
                completion_mode: Some(this.completion_mode),
                tool_use_limit_reached: this.tool_use_limit_reached,
+                profile: Some(this.profile.id().clone()),
            })
        })
    }
@@ -1544,6 +1563,9 @@ impl Thread {
                            Err(LanguageModelCompletionError::Other(error)) => {
                                return Err(error);
                            }
+                            Err(err @ LanguageModelCompletionError::RateLimit(..)) => {
+                                return Err(err.into());
+                            }
                        };

                        match event {
@@ -2121,7 +2143,7 @@ impl Thread {
        window: Option<AnyWindowHandle>,
        cx: &mut Context<Thread>,
    ) {
-        let available_tools = self.tools.read(cx).enabled_tools(cx);
+        let available_tools = self.profile.enabled_tools(cx);

        let tool_list = available_tools
            .iter()
@@ -2213,19 +2235,15 @@ impl Thread {
    ) -> Task<()> {
        let tool_name: Arc<str> = tool.name().into();

-        let tool_result = if self.tools.read(cx).is_disabled(&tool.source(), &tool_name) {
-            Task::ready(Err(anyhow!("tool is disabled: {tool_name}"))).into()
-        } else {
-            tool.run(
-                input,
-                request,
-                self.project.clone(),
-                self.action_log.clone(),
-                model,
-                window,
-                cx,
-            )
-        };
+        let tool_result = tool.run(
+            input,
+            request,
+            self.project.clone(),
+            self.action_log.clone(),
+            model,
+            window,
+            cx,
+        );

        // Store the card separately if it exists
        if let Some(card) = tool_result.card.clone() {
@@ -2344,8 +2362,7 @@ impl Thread {
        let client = self.project.read(cx).client();

        let enabled_tool_names: Vec<String> = self
-            .tools()
-            .read(cx)
+            .profile
            .enabled_tools(cx)
            .iter()
            .map(|tool| tool.name())
@@ -2858,6 +2875,7 @@ pub enum ThreadEvent {
    ToolUseLimitReached,
    CancelEditing,
    CompletionCanceled,
+    ProfileChanged,
 }

 impl EventEmitter<ThreadEvent> for Thread {}
@@ -2872,7 +2890,7 @@ struct PendingCompletion {
 mod tests {
    use super::*;
    use crate::{ThreadStore, context::load_context, context_store::ContextStore, thread_store};
-    use agent_settings::{AgentSettings, LanguageModelParameters};
+    use agent_settings::{AgentProfileId, AgentSettings, LanguageModelParameters};
    use assistant_tool::ToolRegistry;
    use editor::EditorSettings;
    use gpui::TestAppContext;
@@ -3285,6 +3303,71 @@ fn main() {{
        );
    }

+    #[gpui::test]
+    async fn test_storing_profile_setting_per_thread(cx: &mut TestAppContext) {
+        init_test_settings(cx);
+
+        let project = create_test_project(
+            cx,
+            json!({"code.rs": "fn main() {\n    println!(\"Hello, world!\");\n}"}),
+        )
+        .await;
+
+        let (_workspace, thread_store, thread, _context_store, _model) =
+            setup_test_environment(cx, project.clone()).await;
+
+        // Check that we are starting with the default profile
+        let profile = cx.read(|cx| thread.read(cx).profile.clone());
+        let tool_set = cx.read(|cx| thread_store.read(cx).tools());
+        assert_eq!(
+            profile,
+            AgentProfile::new(AgentProfileId::default(), tool_set)
+        );
+    }
+
+    #[gpui::test]
+    async fn test_serializing_thread_profile(cx: &mut TestAppContext) {
+        init_test_settings(cx);
+
+        let project = create_test_project(
+            cx,
+            json!({"code.rs": "fn main() {\n    println!(\"Hello, world!\");\n}"}),
+        )
+        .await;
+
+        let (_workspace, thread_store, thread, _context_store, _model) =
+            setup_test_environment(cx, project.clone()).await;
+
+        // Profile gets serialized with default values
+        let serialized = thread
+            .update(cx, |thread, cx| thread.serialize(cx))
+            .await
+            .unwrap();
+
+        assert_eq!(serialized.profile, Some(AgentProfileId::default()));
+
+        let deserialized = cx.update(|cx| {
+            thread.update(cx, |thread, cx| {
+                Thread::deserialize(
+                    thread.id.clone(),
+                    serialized,
+                    thread.project.clone(),
+                    thread.tools.clone(),
+                    thread.prompt_builder.clone(),
+                    thread.project_context.clone(),
+                    None,
+                    cx,
+                )
+            })
+        });
+        let tool_set = cx.read(|cx| thread_store.read(cx).tools());
+
+        assert_eq!(
+            deserialized.profile,
+            AgentProfile::new(AgentProfileId::default(), tool_set)
+        );
+    }
+
    #[gpui::test]
    async fn test_temperature_setting(cx: &mut TestAppContext) {
        init_test_settings(cx);
--- a/crates/agent/src/thread_history.rs
+++ b/crates/agent/src/thread_history.rs
@@ -594,10 +594,11 @@ impl Render for ThreadHistory {
                    view.pr_5()
                        .child(
                            uniform_list(
-                                cx.entity().clone(),
                                "thread-history",
                                self.list_item_count(),
-                                Self::list_items,
+                                cx.processor(|this, range: Range<usize>, window, cx| {
+                                    this.list_items(range, window, cx)
+                                }),
                            )
                            .p_1()
                            .track_scroll(self.scroll_handle.clone())
@@ -671,7 +672,7 @@ impl RenderOnce for HistoryEntryElement {
            ),
            HistoryEntry::Context(context) => (
                context.path.to_string_lossy().to_string(),
-                context.title.clone().into(),
+                context.title.clone(),
                context.mtime.timestamp(),
            ),
        };
--- a/crates/agent/src/thread_store.rs
+++ b/crates/agent/src/thread_store.rs
@@ -3,9 +3,9 @@ use std::path::{Path, PathBuf};
 use std::rc::Rc;
 use std::sync::{Arc, Mutex};

-use agent_settings::{AgentProfile, AgentProfileId, AgentSettings, CompletionMode};
+use agent_settings::{AgentProfileId, CompletionMode};
 use anyhow::{Context as _, Result, anyhow};
-use assistant_tool::{ToolId, ToolSource, ToolWorkingSet};
+use assistant_tool::{ToolId, ToolWorkingSet};
 use chrono::{DateTime, Utc};
 use collections::HashMap;
 use context_server::ContextServerId;
@@ -25,7 +25,6 @@ use prompt_store::{
    UserRulesContext, WorktreeContext,
 };
 use serde::{Deserialize, Serialize};
-use settings::{Settings as _, SettingsStore};
 use ui::Window;
 use util::ResultExt as _;

@@ -90,7 +89,7 @@ pub fn init(cx: &mut App) {
 pub struct SharedProjectContext(Rc<RefCell<Option<ProjectContext>>>);

 impl SharedProjectContext {
-    pub fn borrow(&self) -> Ref<Option<ProjectContext>> {
+    pub fn borrow(&self) -> Ref<'_, Option<ProjectContext>> {
        self.0.borrow()
    }
 }
@@ -147,12 +146,7 @@ impl ThreadStore {
        prompt_store: Option<Entity<PromptStore>>,
        cx: &mut Context<Self>,
    ) -> (Self, oneshot::Receiver<()>) {
-        let mut subscriptions = vec![
-            cx.observe_global::<SettingsStore>(move |this: &mut Self, cx| {
-                this.load_default_profile(cx);
-            }),
-            cx.subscribe(&project, Self::handle_project_event),
-        ];
+        let mut subscriptions = vec![cx.subscribe(&project, Self::handle_project_event)];

        if let Some(prompt_store) = prompt_store.as_ref() {
            subscriptions.push(cx.subscribe(
@@ -200,7 +194,6 @@ impl ThreadStore {
            _reload_system_prompt_task: reload_system_prompt_task,
            _subscriptions: subscriptions,
        };
-        this.load_default_profile(cx);
        this.register_context_server_handlers(cx);
        this.reload(cx).detach_and_log_err(cx);
        (this, ready_rx)
@@ -400,16 +393,11 @@ impl ThreadStore {
        self.threads.len()
    }

-    pub fn unordered_threads(&self) -> impl Iterator<Item = &SerializedThreadMetadata> {
+    pub fn reverse_chronological_threads(&self) -> impl Iterator<Item = &SerializedThreadMetadata> {
+        // ordering is from "ORDER BY" in `list_threads`
        self.threads.iter()
    }

-    pub fn reverse_chronological_threads(&self) -> Vec<SerializedThreadMetadata> {
-        let mut threads = self.threads.iter().cloned().collect::<Vec<_>>();
-        threads.sort_unstable_by_key(|thread| std::cmp::Reverse(thread.updated_at));
-        threads
-    }
-
    pub fn create_thread(&mut self, cx: &mut Context<Self>) -> Entity<Thread> {
        cx.new(|cx| {
            Thread::new(
@@ -520,92 +508,15 @@ impl ThreadStore {
        })
    }

-    fn load_default_profile(&self, cx: &mut Context<Self>) {
-        let assistant_settings = AgentSettings::get_global(cx);
-
-        self.load_profile_by_id(assistant_settings.default_profile.clone(), cx);
-    }
-
-    pub fn load_profile_by_id(&self, profile_id: AgentProfileId, cx: &mut Context<Self>) {
-        let assistant_settings = AgentSettings::get_global(cx);
-
-        if let Some(profile) = assistant_settings.profiles.get(&profile_id) {
-            self.load_profile(profile.clone(), cx);
-        }
-    }
-
-    pub fn load_profile(&self, profile: AgentProfile, cx: &mut Context<Self>) {
-        self.tools.update(cx, |tools, cx| {
-            tools.disable_all_tools(cx);
-            tools.enable(
-                ToolSource::Native,
-                &profile
-                    .tools
-                    .into_iter()
-                    .filter_map(|(tool, enabled)| enabled.then(|| tool))
-                    .collect::<Vec<_>>(),
-                cx,
-            );
-        });
-
-        if profile.enable_all_context_servers {
-            for context_server_id in self
-                .project
-                .read(cx)
-                .context_server_store()
-                .read(cx)
-                .all_server_ids()
-            {
-                self.tools.update(cx, |tools, cx| {
-                    tools.enable_source(
-                        ToolSource::ContextServer {
-                            id: context_server_id.0.into(),
-                        },
-                        cx,
-                    );
-                });
-            }
-            // Enable all the tools from all context servers, but disable the ones that are explicitly disabled
-            for (context_server_id, preset) in profile.context_servers {
-                self.tools.update(cx, |tools, cx| {
-                    tools.disable(
-                        ToolSource::ContextServer {
-                            id: context_server_id.into(),
-                        },
-                        &preset
-                            .tools
-                            .into_iter()
-                            .filter_map(|(tool, enabled)| (!enabled).then(|| tool))
-                            .collect::<Vec<_>>(),
-                        cx,
-                    )
-                })
-            }
-        } else {
-            for (context_server_id, preset) in profile.context_servers {
-                self.tools.update(cx, |tools, cx| {
-                    tools.enable(
-                        ToolSource::ContextServer {
-                            id: context_server_id.into(),
-                        },
-                        &preset
-                            .tools
-                            .into_iter()
-                            .filter_map(|(tool, enabled)| enabled.then(|| tool))
-                            .collect::<Vec<_>>(),
-                        cx,
-                    )
-                })
-            }
-        }
-    }
-
    fn register_context_server_handlers(&self, cx: &mut Context<Self>) {
-        cx.subscribe(
-            &self.project.read(cx).context_server_store(),
-            Self::handle_context_server_event,
-        )
-        .detach();
+        let context_server_store = self.project.read(cx).context_server_store();
+        cx.subscribe(&context_server_store, Self::handle_context_server_event)
+            .detach();
+
+        // Check for any servers that were already running before the handler was registered
+        for server in context_server_store.read(cx).running_servers() {
+            self.load_context_server_tools(server.id(), context_server_store.clone(), cx);
+        }
    }

    fn handle_context_server_event(
@@ -618,71 +529,71 @@ impl ThreadStore {
        match event {
            project::context_server_store::Event::ServerStatusChanged { server_id, status } => {
                match status {
+                    ContextServerStatus::Starting => {}
                    ContextServerStatus::Running => {
-                        if let Some(server) =
-                            context_server_store.read(cx).get_running_server(server_id)
-                        {
-                            let context_server_manager = context_server_store.clone();
-                            cx.spawn({
-                                let server = server.clone();
-                                let server_id = server_id.clone();
-                                async move |this, cx| {
-                                    let Some(protocol) = server.client() else {
-                                        return;
-                                    };
-
-                                    if protocol.capable(context_server::protocol::ServerCapability::Tools) {
-                                        if let Some(tools) = protocol.list_tools().await.log_err() {
-                                            let tool_ids = tool_working_set
-                                                .update(cx, |tool_working_set, _| {
-                                                    tools
-                                                        .tools
-                                                        .into_iter()
-                                                        .map(|tool| {
-                                                            log::info!(
-                                                                "registering context server tool: {:?}",
-                                                                tool.name
-                                                            );
-                                                            tool_working_set.insert(Arc::new(
-                                                                ContextServerTool::new(
-                                                                    context_server_manager.clone(),
-                                                                    server.id(),
-                                                                    tool,
-                                                                ),
-                                                            ))
-                                                        })
-                                                        .collect::<Vec<_>>()
-                                                })
-                                                .log_err();
-
-                                            if let Some(tool_ids) = tool_ids {
-                                                this.update(cx, |this, cx| {
-                                                    this.context_server_tool_ids
-                                                        .insert(server_id, tool_ids);
-                                                    this.load_default_profile(cx);
-                                                })
-                                                .log_err();
-                                            }
-                                        }
-                                    }
-                                }
-                            })
-                            .detach();
-                        }
+                        self.load_context_server_tools(server_id.clone(), context_server_store, cx);
                    }
                    ContextServerStatus::Stopped | ContextServerStatus::Error(_) => {
                        if let Some(tool_ids) = self.context_server_tool_ids.remove(server_id) {
                            tool_working_set.update(cx, |tool_working_set, _| {
                                tool_working_set.remove(&tool_ids);
                            });
-                            self.load_default_profile(cx);
                        }
                    }
-                    _ => {}
                }
            }
        }
    }
+
+    fn load_context_server_tools(
+        &self,
+        server_id: ContextServerId,
+        context_server_store: Entity<ContextServerStore>,
+        cx: &mut Context<Self>,
+    ) {
+        let Some(server) = context_server_store.read(cx).get_running_server(&server_id) else {
+            return;
+        };
+        let tool_working_set = self.tools.clone();
+        cx.spawn(async move |this, cx| {
+            let Some(protocol) = server.client() else {
+                return;
+            };
+
+            if protocol.capable(context_server::protocol::ServerCapability::Tools) {
+                if let Some(response) = protocol
+                    .request::<context_server::types::requests::ListTools>(())
+                    .await
+                    .log_err()
+                {
+                    let tool_ids = tool_working_set
+                        .update(cx, |tool_working_set, _| {
+                            response
+                                .tools
+                                .into_iter()
+                                .map(|tool| {
+                                    log::info!("registering context server tool: {:?}", tool.name);
+                                    tool_working_set.insert(Arc::new(ContextServerTool::new(
+                                        context_server_store.clone(),
+                                        server.id(),
+                                        tool,
+                                    )))
+                                })
+                                .collect::<Vec<_>>()
+                        })
+                        .log_err();
+
+                    if let Some(tool_ids) = tool_ids {
+                        this.update(cx, |this, _| {
+                            this.context_server_tool_ids.insert(server_id, tool_ids);
+                        })
+                        .log_err();
+                    }
+                }
+            }
+        })
+        .detach();
+    }
 }

 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -692,7 +603,7 @@ pub struct SerializedThreadMetadata {
    pub updated_at: DateTime<Utc>,
 }

-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Serialize, Deserialize, Debug, PartialEq)]
 pub struct SerializedThread {
    pub version: String,
    pub summary: SharedString,
@@ -714,9 +625,11 @@ pub struct SerializedThread {
    pub completion_mode: Option<CompletionMode>,
    #[serde(default)]
    pub tool_use_limit_reached: bool,
+    #[serde(default)]
+    pub profile: Option<AgentProfileId>,
 }

-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Serialize, Deserialize, Debug, PartialEq)]
 pub struct SerializedLanguageModel {
    pub provider: String,
    pub model: String,
@@ -777,11 +690,15 @@ impl SerializedThreadV0_1_0 {
            messages.push(message);
        }

-        SerializedThread { messages, ..self.0 }
+        SerializedThread {
+            messages,
+            version: SerializedThread::VERSION.to_string(),
+            ..self.0
+        }
    }
 }

-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize, Deserialize, PartialEq)]
 pub struct SerializedMessage {
    pub id: MessageId,
    pub role: Role,
@@ -799,7 +716,7 @@ pub struct SerializedMessage {
    pub is_hidden: bool,
 }

-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize, Deserialize, PartialEq)]
 #[serde(tag = "type")]
 pub enum SerializedMessageSegment {
    #[serde(rename = "text")]
@@ -817,14 +734,14 @@ pub enum SerializedMessageSegment {
    },
 }

-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize, Deserialize, PartialEq)]
 pub struct SerializedToolUse {
    pub id: LanguageModelToolUseId,
    pub name: SharedString,
    pub input: serde_json::Value,
 }

-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize, Deserialize, PartialEq)]
 pub struct SerializedToolResult {
    pub tool_use_id: LanguageModelToolUseId,
    pub is_error: bool,
@@ -856,6 +773,7 @@ impl LegacySerializedThread {
            model: None,
            completion_mode: None,
            tool_use_limit_reached: false,
+            profile: None,
        }
    }
 }
@@ -886,7 +804,7 @@ impl LegacySerializedMessage {
    }
 }

-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize, Deserialize, PartialEq)]
 pub struct SerializedCrease {
    pub start: usize,
    pub end: usize,
@@ -1005,7 +923,7 @@ impl ThreadsDatabase {

            fn bytes_encode(
                item: &Self::EItem,
-            ) -> Result<std::borrow::Cow<[u8]>, heed::BoxedError> {
+            ) -> Result<std::borrow::Cow<'_, [u8]>, heed::BoxedError> {
                serde_json::to_vec(&item.0)
                    .map(std::borrow::Cow::Owned)
                    .map_err(Into::into)
@@ -1143,3 +1061,181 @@ impl ThreadsDatabase {
        })
    }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::thread::{DetailedSummaryState, MessageId};
+    use chrono::Utc;
+    use language_model::{Role, TokenUsage};
+    use pretty_assertions::assert_eq;
+
+    #[test]
+    fn test_legacy_serialized_thread_upgrade() {
+        let updated_at = Utc::now();
+        let legacy_thread = LegacySerializedThread {
+            summary: "Test conversation".into(),
+            updated_at,
+            messages: vec![LegacySerializedMessage {
+                id: MessageId(1),
+                role: Role::User,
+                text: "Hello, world!".to_string(),
+                tool_uses: vec![],
+                tool_results: vec![],
+            }],
+            initial_project_snapshot: None,
+        };
+
+        let upgraded = legacy_thread.upgrade();
+
+        assert_eq!(
+            upgraded,
+            SerializedThread {
+                summary: "Test conversation".into(),
+                updated_at,
+                messages: vec![SerializedMessage {
+                    id: MessageId(1),
+                    role: Role::User,
+                    segments: vec![SerializedMessageSegment::Text {
+                        text: "Hello, world!".to_string()
+                    }],
+                    tool_uses: vec![],
+                    tool_results: vec![],
+                    context: "".to_string(),
+                    creases: vec![],
+                    is_hidden: false
+                }],
+                version: SerializedThread::VERSION.to_string(),
+                initial_project_snapshot: None,
+                cumulative_token_usage: TokenUsage::default(),
+                request_token_usage: vec![],
+                detailed_summary_state: DetailedSummaryState::default(),
+                exceeded_window_error: None,
+                model: None,
+                completion_mode: None,
+                tool_use_limit_reached: false,
+                profile: None
+            }
+        )
+    }
+
+    #[test]
+    fn test_serialized_threadv0_1_0_upgrade() {
+        let updated_at = Utc::now();
+        let thread_v0_1_0 = SerializedThreadV0_1_0(SerializedThread {
+            summary: "Test conversation".into(),
+            updated_at,
+            messages: vec![
+                SerializedMessage {
+                    id: MessageId(1),
+                    role: Role::User,
+                    segments: vec![SerializedMessageSegment::Text {
+                        text: "Use tool_1".to_string(),
+                    }],
+                    tool_uses: vec![],
+                    tool_results: vec![],
+                    context: "".to_string(),
+                    creases: vec![],
+                    is_hidden: false,
+                },
+                SerializedMessage {
+                    id: MessageId(2),
+                    role: Role::Assistant,
+                    segments: vec![SerializedMessageSegment::Text {
+                        text: "I want to use a tool".to_string(),
+                    }],
+                    tool_uses: vec![SerializedToolUse {
+                        id: "abc".into(),
+                        name: "tool_1".into(),
+                        input: serde_json::Value::Null,
+                    }],
+                    tool_results: vec![],
+                    context: "".to_string(),
+                    creases: vec![],
+                    is_hidden: false,
+                },
+                SerializedMessage {
+                    id: MessageId(1),
+                    role: Role::User,
+                    segments: vec![SerializedMessageSegment::Text {
+                        text: "Here is the tool result".to_string(),
+                    }],
+                    tool_uses: vec![],
+                    tool_results: vec![SerializedToolResult {
+                        tool_use_id: "abc".into(),
+                        is_error: false,
+                        content: LanguageModelToolResultContent::Text("abcdef".into()),
+                        output: Some(serde_json::Value::Null),
+                    }],
+                    context: "".to_string(),
+                    creases: vec![],
+                    is_hidden: false,
+                },
+            ],
+            version: SerializedThreadV0_1_0::VERSION.to_string(),
+            initial_project_snapshot: None,
+            cumulative_token_usage: TokenUsage::default(),
+            request_token_usage: vec![],
+            detailed_summary_state: DetailedSummaryState::default(),
+            exceeded_window_error: None,
+            model: None,
+            completion_mode: None,
+            tool_use_limit_reached: false,
+            profile: None,
+        });
+        let upgraded = thread_v0_1_0.upgrade();
+
+        assert_eq!(
+            upgraded,
+            SerializedThread {
+                summary: "Test conversation".into(),
+                updated_at,
+                messages: vec![
+                    SerializedMessage {
+                        id: MessageId(1),
+                        role: Role::User,
+                        segments: vec![SerializedMessageSegment::Text {
+                            text: "Use tool_1".to_string()
+                        }],
+                        tool_uses: vec![],
+                        tool_results: vec![],
+                        context: "".to_string(),
+                        creases: vec![],
+                        is_hidden: false
+                    },
+                    SerializedMessage {
+                        id: MessageId(2),
+                        role: Role::Assistant,
+                        segments: vec![SerializedMessageSegment::Text {
+                            text: "I want to use a tool".to_string(),
+                        }],
+                        tool_uses: vec![SerializedToolUse {
+                            id: "abc".into(),
+                            name: "tool_1".into(),
+                            input: serde_json::Value::Null,
+                        }],
+                        tool_results: vec![SerializedToolResult {
+                            tool_use_id: "abc".into(),
+                            is_error: false,
+                            content: LanguageModelToolResultContent::Text("abcdef".into()),
+                            output: Some(serde_json::Value::Null),
+                        }],
+                        context: "".to_string(),
+                        creases: vec![],
+                        is_hidden: false,
+                    },
+                ],
+                version: SerializedThread::VERSION.to_string(),
+                initial_project_snapshot: None,
+                cumulative_token_usage: TokenUsage::default(),
+                request_token_usage: vec![],
+                detailed_summary_state: DetailedSummaryState::default(),
+                exceeded_window_error: None,
+                model: None,
+                completion_mode: None,
+                tool_use_limit_reached: false,
+                profile: None
+            }
+        )
+    }
+}
--- a/crates/agent/src/tool_compatibility.rs
+++ b/crates/agent/src/tool_compatibility.rs
@@ -1,30 +1,33 @@
 use std::sync::Arc;

-use assistant_tool::{Tool, ToolSource, ToolWorkingSet, ToolWorkingSetEvent};
+use assistant_tool::{Tool, ToolSource};
 use collections::HashMap;
 use gpui::{App, Context, Entity, IntoElement, Render, Subscription, Window};
 use language_model::{LanguageModel, LanguageModelToolSchemaFormat};
 use ui::prelude::*;

+use crate::{Thread, ThreadEvent};
+
 pub struct IncompatibleToolsState {
    cache: HashMap<LanguageModelToolSchemaFormat, Vec<Arc<dyn Tool>>>,
-    tool_working_set: Entity<ToolWorkingSet>,
-    _tool_working_set_subscription: Subscription,
+    thread: Entity<Thread>,
+    _thread_subscription: Subscription,
 }

 impl IncompatibleToolsState {
-    pub fn new(tool_working_set: Entity<ToolWorkingSet>, cx: &mut Context<Self>) -> Self {
+    pub fn new(thread: Entity<Thread>, cx: &mut Context<Self>) -> Self {
        let _tool_working_set_subscription =
-            cx.subscribe(&tool_working_set, |this, _, event, _| match event {
-                ToolWorkingSetEvent::EnabledToolsChanged => {
+            cx.subscribe(&thread, |this, _, event, _| match event {
+                ThreadEvent::ProfileChanged => {
                    this.cache.clear();
                }
+                _ => {}
            });

        Self {
            cache: HashMap::default(),
-            tool_working_set,
-            _tool_working_set_subscription,
+            thread,
+            _thread_subscription: _tool_working_set_subscription,
        }
    }

@@ -36,8 +39,9 @@ impl IncompatibleToolsState {
        self.cache
            .entry(model.tool_input_format())
            .or_insert_with(|| {
-                self.tool_working_set
+                self.thread
                    .read(cx)
+                    .profile()
                    .enabled_tools(cx)
                    .iter()
                    .filter(|tool| tool.input_schema(model.tool_input_format()).is_err())
--- a/crates/agent_settings/Cargo.toml
+++ b/crates/agent_settings/Cargo.toml
@@ -16,7 +16,6 @@ anthropic = { workspace = true, features = ["schemars"] }
 anyhow.workspace = true
 collections.workspace = true
 gpui.workspace = true
-indexmap.workspace = true
 language_model.workspace = true
 lmstudio = { workspace = true, features = ["schemars"] }
 log.workspace = true
--- a/crates/agent_settings/src/agent_profile.rs
+++ b/crates/agent_settings/src/agent_profile.rs
@@ -17,29 +17,6 @@ pub mod builtin_profiles {
    }
 }

-#[derive(Default)]
-pub struct GroupedAgentProfiles {
-    pub builtin: IndexMap<AgentProfileId, AgentProfile>,
-    pub custom: IndexMap<AgentProfileId, AgentProfile>,
-}
-
-impl GroupedAgentProfiles {
-    pub fn from_settings(settings: &crate::AgentSettings) -> Self {
-        let mut builtin = IndexMap::default();
-        let mut custom = IndexMap::default();
-
-        for (profile_id, profile) in settings.profiles.clone() {
-            if builtin_profiles::is_builtin(&profile_id) {
-                builtin.insert(profile_id, profile);
-            } else {
-                custom.insert(profile_id, profile);
-            }
-        }
-
-        Self { builtin, custom }
-    }
-}
-
 #[derive(Debug, PartialEq, Eq, Hash, Clone, Serialize, Deserialize, JsonSchema)]
 pub struct AgentProfileId(pub Arc<str>);

@@ -63,7 +40,7 @@ impl Default for AgentProfileId {

 /// A profile for the Zed Agent that controls its behavior.
 #[derive(Debug, Clone)]
-pub struct AgentProfile {
+pub struct AgentProfileSettings {
    /// The name of the profile.
    pub name: SharedString,
    pub tools: IndexMap<Arc<str>, bool>,
--- a/crates/agent_settings/src/agent_settings.rs
+++ b/crates/agent_settings/src/agent_settings.rs
@@ -102,7 +102,7 @@ pub struct AgentSettings {
    pub using_outdated_settings_version: bool,
    pub default_profile: AgentProfileId,
    pub default_view: DefaultView,
-    pub profiles: IndexMap<AgentProfileId, AgentProfile>,
+    pub profiles: IndexMap<AgentProfileId, AgentProfileSettings>,
    pub always_allow_tool_actions: bool,
    pub notify_when_agent_waiting: NotifyWhenAgentWaiting,
    pub play_sound_when_agent_done: bool,
@@ -531,7 +531,7 @@ impl AgentSettingsContent {
    pub fn create_profile(
        &mut self,
        profile_id: AgentProfileId,
-        profile: AgentProfile,
+        profile_settings: AgentProfileSettings,
    ) -> Result<()> {
        self.v2_setting(|settings| {
            let profiles = settings.profiles.get_or_insert_default();
@@ -542,10 +542,10 @@ impl AgentSettingsContent {
            profiles.insert(
                profile_id,
                AgentProfileContent {
-                    name: profile.name.into(),
-                    tools: profile.tools,
-                    enable_all_context_servers: Some(profile.enable_all_context_servers),
-                    context_servers: profile
+                    name: profile_settings.name.into(),
+                    tools: profile_settings.tools,
+                    enable_all_context_servers: Some(profile_settings.enable_all_context_servers),
+                    context_servers: profile_settings
                        .context_servers
                        .into_iter()
                        .map(|(server_id, preset)| {
@@ -910,7 +910,7 @@ impl Settings for AgentSettings {
                    .extend(profiles.into_iter().map(|(id, profile)| {
                        (
                            id,
-                            AgentProfile {
+                            AgentProfileSettings {
                                name: profile.name.into(),
                                tools: profile.tools,
                                enable_all_context_servers: profile
--- a/crates/anthropic/src/anthropic.rs
+++ b/crates/anthropic/src/anthropic.rs
@@ -1,4 +1,5 @@
 use std::str::FromStr;
+use std::time::Duration;

 use anyhow::{Context as _, Result, anyhow};
 use chrono::{DateTime, Utc};
@@ -406,6 +407,7 @@ impl RateLimit {
 /// <https://docs.anthropic.com/en/api/rate-limits#response-headers>
 #[derive(Debug)]
 pub struct RateLimitInfo {
+    pub retry_after: Option<Duration>,
    pub requests: Option<RateLimit>,
    pub tokens: Option<RateLimit>,
    pub input_tokens: Option<RateLimit>,
@@ -417,10 +419,11 @@ impl RateLimitInfo {
        // Check if any rate limit headers exist
        let has_rate_limit_headers = headers
            .keys()
-            .any(|k| k.as_str().starts_with("anthropic-ratelimit-"));
+            .any(|k| k == "retry-after" || k.as_str().starts_with("anthropic-ratelimit-"));

        if !has_rate_limit_headers {
            return Self {
+                retry_after: None,
                requests: None,
                tokens: None,
                input_tokens: None,
@@ -429,6 +432,11 @@ impl RateLimitInfo {
        }

        Self {
+            retry_after: headers
+                .get("retry-after")
+                .and_then(|v| v.to_str().ok())
+                .and_then(|v| v.parse::<u64>().ok())
+                .map(Duration::from_secs),
            requests: RateLimit::from_headers("requests", headers).ok(),
            tokens: RateLimit::from_headers("tokens", headers).ok(),
            input_tokens: RateLimit::from_headers("input-tokens", headers).ok(),
@@ -481,8 +489,8 @@ pub async fn stream_completion_with_rate_limit_info(
        .send(request)
        .await
        .context("failed to send request to Anthropic")?;
+    let rate_limits = RateLimitInfo::from_headers(response.headers());
    if response.status().is_success() {
-        let rate_limits = RateLimitInfo::from_headers(response.headers());
        let reader = BufReader::new(response.into_body());
        let stream = reader
            .lines()
@@ -500,6 +508,8 @@ pub async fn stream_completion_with_rate_limit_info(
            })
            .boxed();
        Ok((stream, Some(rate_limits)))
+    } else if let Some(retry_after) = rate_limits.retry_after {
+        Err(AnthropicError::RateLimit(retry_after))
    } else {
        let mut body = Vec::new();
        response
@@ -769,6 +779,8 @@ pub struct MessageDelta {

 #[derive(Error, Debug)]
 pub enum AnthropicError {
+    #[error("rate limit exceeded, retry after {0:?}")]
+    RateLimit(Duration),
    #[error("an error occurred while interacting with the Anthropic API: {error_type}: {message}", error_type = .0.error_type, message = .0.message)]
    ApiError(ApiError),
    #[error("{0}")]
--- a/crates/assistant_context_editor/src/context.rs
+++ b/crates/assistant_context_editor/src/context.rs
@@ -11,7 +11,7 @@ use assistant_slash_commands::FileCommandMetadata;
 use client::{self, proto, telemetry::Telemetry};
 use clock::ReplicaId;
 use collections::{HashMap, HashSet};
-use fs::{Fs, RemoveOptions};
+use fs::{Fs, RenameOptions};
 use futures::{FutureExt, StreamExt, future::Shared};
 use gpui::{
    App, AppContext as _, Context, Entity, EventEmitter, RenderImage, SharedString, Subscription,
@@ -452,6 +452,10 @@ pub enum ContextEvent {
    MessagesEdited,
    SummaryChanged,
    SummaryGenerated,
+    PathChanged {
+        old_path: Option<Arc<Path>>,
+        new_path: Arc<Path>,
+    },
    StreamedCompletion,
    StartedThoughtProcess(Range<language::Anchor>),
    EndedThoughtProcess(language::Anchor),
@@ -2894,22 +2898,34 @@ impl AssistantContext {
                }

                fs.create_dir(contexts_dir().as_ref()).await?;
-                fs.atomic_write(new_path.clone(), serde_json::to_string(&context).unwrap())
-                    .await?;
-                if let Some(old_path) = old_path {
+
+                // rename before write ensures that only one file exists
+                if let Some(old_path) = old_path.as_ref() {
                    if new_path.as_path() != old_path.as_ref() {
-                        fs.remove_file(
+                        fs.rename(
                            &old_path,
-                            RemoveOptions {
-                                recursive: false,
-                                ignore_if_not_exists: true,
+                            &new_path,
+                            RenameOptions {
+                                overwrite: true,
+                                ignore_if_exists: true,
                            },
                        )
                        .await?;
                    }
                }

-                this.update(cx, |this, _| this.path = Some(new_path.into()))?;
+                // update path before write in case it fails
+                this.update(cx, {
+                    let new_path: Arc<Path> = new_path.clone().into();
+                    move |this, cx| {
+                        this.path = Some(new_path.clone());
+                        cx.emit(ContextEvent::PathChanged { old_path, new_path });
+                    }
+                })
+                .ok();
+
+                fs.atomic_write(new_path, serde_json::to_string(&context).unwrap())
+                    .await?;
            }

            Ok(())
@@ -3277,7 +3293,7 @@ impl SavedContextV0_1_0 {

 #[derive(Debug, Clone)]
 pub struct SavedContextMetadata {
-    pub title: String,
+    pub title: SharedString,
    pub path: Arc<Path>,
    pub mtime: chrono::DateTime<chrono::Local>,
 }
--- a/crates/assistant_context_editor/src/context_editor.rs
+++ b/crates/assistant_context_editor/src/context_editor.rs
@@ -580,6 +580,7 @@ impl ContextEditor {
                });
            }
            ContextEvent::SummaryGenerated => {}
+            ContextEvent::PathChanged { .. } => {}
            ContextEvent::StartedThoughtProcess(range) => {
                let creases = self.insert_thought_process_output_sections(
                    [(
--- a/crates/assistant_context_editor/src/context_store.rs
+++ b/crates/assistant_context_editor/src/context_store.rs
@@ -347,12 +347,6 @@ impl ContextStore {
        self.contexts_metadata.iter()
    }

-    pub fn reverse_chronological_contexts(&self) -> Vec<SavedContextMetadata> {
-        let mut contexts = self.contexts_metadata.iter().cloned().collect::<Vec<_>>();
-        contexts.sort_unstable_by_key(|thread| std::cmp::Reverse(thread.mtime));
-        contexts
-    }
-
    pub fn create(&mut self, cx: &mut Context<Self>) -> Entity<AssistantContext> {
        let context = cx.new(|cx| {
            AssistantContext::local(
@@ -618,6 +612,16 @@ impl ContextStore {
            ContextEvent::SummaryChanged => {
                self.advertise_contexts(cx);
            }
+            ContextEvent::PathChanged { old_path, new_path } => {
+                if let Some(old_path) = old_path.as_ref() {
+                    for metadata in &mut self.contexts_metadata {
+                        if &metadata.path == old_path {
+                            metadata.path = new_path.clone();
+                            break;
+                        }
+                    }
+                }
+            }
            ContextEvent::Operation(operation) => {
                let context_id = context.read(cx).id().to_proto();
                let operation = operation.to_proto();
@@ -792,7 +796,7 @@ impl ContextStore {
                        .next()
                    {
                        contexts.push(SavedContextMetadata {
-                            title: title.to_string(),
+                            title: title.to_string().into(),
                            path: path.into(),
                            mtime: metadata.mtime.timestamp_for_user().into(),
                        });
@@ -809,74 +813,37 @@ impl ContextStore {
    }

    fn register_context_server_handlers(&self, cx: &mut Context<Self>) {
-        cx.subscribe(
-            &self.project.read(cx).context_server_store(),
-            Self::handle_context_server_event,
-        )
-        .detach();
+        let context_server_store = self.project.read(cx).context_server_store();
+        cx.subscribe(&context_server_store, Self::handle_context_server_event)
+            .detach();
+
+        // Check for any servers that were already running before the handler was registered
+        for server in context_server_store.read(cx).running_servers() {
+            self.load_context_server_slash_commands(server.id(), context_server_store.clone(), cx);
+        }
    }

    fn handle_context_server_event(
        &mut self,
-        context_server_manager: Entity<ContextServerStore>,
+        context_server_store: Entity<ContextServerStore>,
        event: &project::context_server_store::Event,
        cx: &mut Context<Self>,
    ) {
-        let slash_command_working_set = self.slash_commands.clone();
        match event {
            project::context_server_store::Event::ServerStatusChanged { server_id, status } => {
                match status {
                    ContextServerStatus::Running => {
-                        if let Some(server) = context_server_manager
-                            .read(cx)
-                            .get_running_server(server_id)
-                        {
-                            let context_server_manager = context_server_manager.clone();
-                            cx.spawn({
-                                let server = server.clone();
-                                let server_id = server_id.clone();
-                                async move |this, cx| {
-                                    let Some(protocol) = server.client() else {
-                                        return;
-                                    };
-
-                                    if protocol.capable(context_server::protocol::ServerCapability::Prompts) {
-                                        if let Some(prompts) = protocol.list_prompts().await.log_err() {
-                                            let slash_command_ids = prompts
-                                                .into_iter()
-                                                .filter(assistant_slash_commands::acceptable_prompt)
-                                                .map(|prompt| {
-                                                    log::info!(
-                                                        "registering context server command: {:?}",
-                                                        prompt.name
-                                                    );
-                                                    slash_command_working_set.insert(Arc::new(
-                                                        assistant_slash_commands::ContextServerSlashCommand::new(
-                                                            context_server_manager.clone(),
-                                                            server.id(),
-                                                            prompt,
-                                                        ),
-                                                    ))
-                                                })
-                                                .collect::<Vec<_>>();
-
-                                            this.update( cx, |this, _cx| {
-                                                this.context_server_slash_command_ids
-                                                    .insert(server_id.clone(), slash_command_ids);
-                                            })
-                                            .log_err();
-                                        }
-                                    }
-                                }
-                            })
-                            .detach();
-                        }
+                        self.load_context_server_slash_commands(
+                            server_id.clone(),
+                            context_server_store.clone(),
+                            cx,
+                        );
                    }
                    ContextServerStatus::Stopped | ContextServerStatus::Error(_) => {
                        if let Some(slash_command_ids) =
                            self.context_server_slash_command_ids.remove(server_id)
                        {
-                            slash_command_working_set.remove(&slash_command_ids);
+                            self.slash_commands.remove(&slash_command_ids);
                        }
                    }
                    _ => {}
@@ -884,4 +851,52 @@ impl ContextStore {
            }
        }
    }
+
+    fn load_context_server_slash_commands(
+        &self,
+        server_id: ContextServerId,
+        context_server_store: Entity<ContextServerStore>,
+        cx: &mut Context<Self>,
+    ) {
+        let Some(server) = context_server_store.read(cx).get_running_server(&server_id) else {
+            return;
+        };
+        let slash_command_working_set = self.slash_commands.clone();
+        cx.spawn(async move |this, cx| {
+            let Some(protocol) = server.client() else {
+                return;
+            };
+
+            if protocol.capable(context_server::protocol::ServerCapability::Prompts) {
+                if let Some(response) = protocol
+                    .request::<context_server::types::requests::PromptsList>(())
+                    .await
+                    .log_err()
+                {
+                    let slash_command_ids = response
+                        .prompts
+                        .into_iter()
+                        .filter(assistant_slash_commands::acceptable_prompt)
+                        .map(|prompt| {
+                            log::info!("registering context server command: {:?}", prompt.name);
+                            slash_command_working_set.insert(Arc::new(
+                                assistant_slash_commands::ContextServerSlashCommand::new(
+                                    context_server_store.clone(),
+                                    server.id(),
+                                    prompt,
+                                ),
+                            ))
+                        })
+                        .collect::<Vec<_>>();
+
+                    this.update(cx, |this, _cx| {
+                        this.context_server_slash_command_ids
+                            .insert(server_id.clone(), slash_command_ids);
+                    })
+                    .log_err();
+                }
+            }
+        })
+        .detach();
+    }
 }
--- a/crates/assistant_context_editor/src/language_model_selector.rs
+++ b/crates/assistant_context_editor/src/language_model_selector.rs
@@ -682,11 +682,12 @@ mod tests {
            _: &AsyncApp,
        ) -> BoxFuture<
            'static,
-            http_client::Result<
+            Result<
                BoxStream<
                    'static,
-                    http_client::Result<LanguageModelCompletionEvent, LanguageModelCompletionError>,
+                    Result<LanguageModelCompletionEvent, LanguageModelCompletionError>,
                >,
+                LanguageModelCompletionError,
            >,
        > {
            unimplemented!()
--- a/crates/assistant_context_editor/src/slash_command.rs
+++ b/crates/assistant_context_editor/src/slash_command.rs
@@ -10,9 +10,7 @@ use parking_lot::Mutex;
 use project::{CompletionIntent, CompletionSource, lsp_store::CompletionDocumentation};
 use rope::Point;
 use std::{
-    cell::RefCell,
    ops::Range,
-    rc::Rc,
    sync::{
        Arc,
        atomic::{AtomicBool, Ordering::SeqCst},
@@ -240,13 +238,14 @@ impl SlashCommandCompletionProvider {

                Ok(vec![project::CompletionResponse {
                    completions,
-                    is_incomplete: false,
+                    // TODO: Could have slash commands indicate whether their completions are incomplete.
+                    is_incomplete: true,
                }])
            })
        } else {
            Task::ready(Ok(vec![project::CompletionResponse {
                completions: Vec::new(),
-                is_incomplete: false,
+                is_incomplete: true,
            }]))
        }
    }
@@ -275,17 +274,17 @@ impl CompletionProvider for SlashCommandCompletionProvider {
                    position.row,
                    call.arguments.last().map_or(call.name.end, |arg| arg.end) as u32,
                );
-                let command_range = buffer.anchor_after(command_range_start)
+                let command_range = buffer.anchor_before(command_range_start)
                    ..buffer.anchor_after(command_range_end);

                let name = line[call.name.clone()].to_string();
                let (arguments, last_argument_range) = if let Some(argument) = call.arguments.last()
                {
                    let last_arg_start =
-                        buffer.anchor_after(Point::new(position.row, argument.start as u32));
+                        buffer.anchor_before(Point::new(position.row, argument.start as u32));
                    let first_arg_start = call.arguments.first().expect("we have the last element");
-                    let first_arg_start =
-                        buffer.anchor_after(Point::new(position.row, first_arg_start.start as u32));
+                    let first_arg_start = buffer
+                        .anchor_before(Point::new(position.row, first_arg_start.start as u32));
                    let arguments = call
                        .arguments
                        .into_iter()
@@ -298,7 +297,7 @@ impl CompletionProvider for SlashCommandCompletionProvider {
                    )
                } else {
                    let start =
-                        buffer.anchor_after(Point::new(position.row, call.name.start as u32));
+                        buffer.anchor_before(Point::new(position.row, call.name.start as u32));
                    (None, start..buffer_position)
                };

@@ -326,16 +325,6 @@ impl CompletionProvider for SlashCommandCompletionProvider {
        }
    }

-    fn resolve_completions(
-        &self,
-        _: Entity<Buffer>,
-        _: Vec<usize>,
-        _: Rc<RefCell<Box<[project::Completion]>>>,
-        _: &mut Context<Editor>,
-    ) -> Task<Result<bool>> {
-        Task::ready(Ok(true))
-    }
-
    fn is_completion_trigger(
        &self,
        buffer: &Entity<Buffer>,
--- a/crates/assistant_slash_commands/src/context_server_command.rs
+++ b/crates/assistant_slash_commands/src/context_server_command.rs
@@ -86,20 +86,26 @@ impl SlashCommand for ContextServerSlashCommand {
            cx.foreground_executor().spawn(async move {
                let protocol = server.client().context("Context server not initialized")?;

-                let completion_result = protocol
-                    .completion(
-                        context_server::types::CompletionReference::Prompt(
-                            context_server::types::PromptReference {
-                                r#type: context_server::types::PromptReferenceType::Prompt,
-                                name: prompt_name,
+                let response = protocol
+                    .request::<context_server::types::requests::CompletionComplete>(
+                        context_server::types::CompletionCompleteParams {
+                            reference: context_server::types::CompletionReference::Prompt(
+                                context_server::types::PromptReference {
+                                    ty: context_server::types::PromptReferenceType::Prompt,
+                                    name: prompt_name,
+                                },
+                            ),
+                            argument: context_server::types::CompletionArgument {
+                                name: arg_name,
+                                value: arg_value,
                            },
-                        ),
-                        arg_name,
-                        arg_value,
+                            meta: None,
+                        },
                    )
                    .await?;

-                let completions = completion_result
+                let completions = response
+                    .completion
                    .values
                    .into_iter()
                    .map(|value| ArgumentCompletion {
@@ -138,10 +144,18 @@ impl SlashCommand for ContextServerSlashCommand {
        if let Some(server) = store.get_running_server(&server_id) {
            cx.foreground_executor().spawn(async move {
                let protocol = server.client().context("Context server not initialized")?;
-                let result = protocol.run_prompt(&prompt_name, prompt_args).await?;
+                let response = protocol
+                    .request::<context_server::types::requests::PromptsGet>(
+                        context_server::types::PromptsGetParams {
+                            name: prompt_name.clone(),
+                            arguments: Some(prompt_args),
+                            meta: None,
+                        },
+                    )
+                    .await?;

                anyhow::ensure!(
-                    result
+                    response
                        .messages
                        .iter()
                        .all(|msg| matches!(msg.role, context_server::types::Role::User)),
@@ -149,7 +163,7 @@ impl SlashCommand for ContextServerSlashCommand {
                );

                // Extract text from user messages into a single prompt string
-                let mut prompt = result
+                let mut prompt = response
                    .messages
                    .into_iter()
                    .filter_map(|msg| match msg.content {
@@ -167,7 +181,7 @@ impl SlashCommand for ContextServerSlashCommand {
                        range: 0..(prompt.len()),
                        icon: IconName::ZedAssistant,
                        label: SharedString::from(
-                            result
+                            response
                                .description
                                .unwrap_or(format!("Result from {}", prompt_name)),
                        ),
--- a/crates/assistant_tool/Cargo.toml
+++ b/crates/assistant_tool/Cargo.toml
@@ -13,7 +13,6 @@ path = "src/assistant_tool.rs"

 [dependencies]
 anyhow.workspace = true
-async-watch.workspace = true
 buffer_diff.workspace = true
 clock.workspace = true
 collections.workspace = true
@@ -30,6 +29,7 @@ serde.workspace = true
 serde_json.workspace = true
 text.workspace = true
 util.workspace = true
+watch.workspace = true
 workspace.workspace = true
 workspace-hack.workspace = true

--- a/crates/assistant_tool/src/action_log.rs
+++ b/crates/assistant_tool/src/action_log.rs
@@ -204,7 +204,7 @@ impl ActionLog {
            git_store.repository_and_path_for_buffer_id(buffer.read(cx).remote_id(), cx)
        })?;

-        let (git_diff_updates_tx, mut git_diff_updates_rx) = async_watch::channel(());
+        let (mut git_diff_updates_tx, mut git_diff_updates_rx) = watch::channel(());
        let _repo_subscription =
            if let Some((git_diff, (buffer_repo, _))) = git_diff.as_ref().zip(buffer_repo) {
                cx.update(|cx| {
--- a/crates/assistant_tool/src/assistant_tool.rs
+++ b/crates/assistant_tool/src/assistant_tool.rs
@@ -214,7 +214,7 @@ pub trait Tool: 'static + Send + Sync {
        ToolSource::Native
    }

-    /// Returns true iff the tool needs the users's confirmation
+    /// Returns true if the tool needs the users's confirmation
    /// before having permission to run.
    fn needs_confirmation(&self, input: &serde_json::Value, cx: &App) -> bool;

--- a/crates/assistant_tool/src/tool_schema.rs
+++ b/crates/assistant_tool/src/tool_schema.rs
@@ -46,15 +46,19 @@ fn adapt_to_json_schema_subset(json: &mut Value) -> Result<()> {
            );
        }

-        const KEYS_TO_REMOVE: [&str; 5] = [
-            "format",
-            "additionalProperties",
-            "exclusiveMinimum",
-            "exclusiveMaximum",
-            "optional",
+        const KEYS_TO_REMOVE: [(&str, fn(&Value) -> bool); 5] = [
+            ("format", |value| value.is_string()),
+            ("additionalProperties", |value| value.is_boolean()),
+            ("exclusiveMinimum", |value| value.is_number()),
+            ("exclusiveMaximum", |value| value.is_number()),
+            ("optional", |value| value.is_boolean()),
        ];
-        for key in KEYS_TO_REMOVE {
-            obj.remove(key);
+        for (key, predicate) in KEYS_TO_REMOVE {
+            if let Some(value) = obj.get(key) {
+                if predicate(value) {
+                    obj.remove(key);
+                }
+            }
        }

        // If a type is not specified for an input parameter, add a default type
@@ -153,6 +157,24 @@ mod tests {
                "type": "integer"
            })
        );
+
+        // Ensure that we do not remove keys that are actually supported (e.g. "format" can just be used as another property)
+        let mut json = json!({
+            "description": "A test field",
+            "type": "integer",
+            "format": {},
+        });
+
+        adapt_to_json_schema_subset(&mut json).unwrap();
+
+        assert_eq!(
+            json,
+            json!({
+                "description": "A test field",
+                "type": "integer",
+                "format": {},
+            })
+        );
    }

    #[test]
--- a/crates/assistant_tool/src/tool_working_set.rs
+++ b/crates/assistant_tool/src/tool_working_set.rs
@@ -1,7 +1,7 @@
 use std::sync::Arc;

-use collections::{HashMap, HashSet, IndexMap};
-use gpui::{App, Context, EventEmitter};
+use collections::{HashMap, IndexMap};
+use gpui::App;

 use crate::{Tool, ToolRegistry, ToolSource};

@@ -13,17 +13,9 @@ pub struct ToolId(usize);
 pub struct ToolWorkingSet {
    context_server_tools_by_id: HashMap<ToolId, Arc<dyn Tool>>,
    context_server_tools_by_name: HashMap<String, Arc<dyn Tool>>,
-    enabled_sources: HashSet<ToolSource>,
-    enabled_tools_by_source: HashMap<ToolSource, HashSet<Arc<str>>>,
    next_tool_id: ToolId,
 }

-pub enum ToolWorkingSetEvent {
-    EnabledToolsChanged,
-}
-
-impl EventEmitter<ToolWorkingSetEvent> for ToolWorkingSet {}
-
 impl ToolWorkingSet {
    pub fn tool(&self, name: &str, cx: &App) -> Option<Arc<dyn Tool>> {
        self.context_server_tools_by_name
@@ -57,42 +49,6 @@ impl ToolWorkingSet {
        tools_by_source
    }

-    pub fn enabled_tools(&self, cx: &App) -> Vec<Arc<dyn Tool>> {
-        let all_tools = self.tools(cx);
-
-        all_tools
-            .into_iter()
-            .filter(|tool| self.is_enabled(&tool.source(), &tool.name().into()))
-            .collect()
-    }
-
-    pub fn disable_all_tools(&mut self, cx: &mut Context<Self>) {
-        self.enabled_tools_by_source.clear();
-        cx.emit(ToolWorkingSetEvent::EnabledToolsChanged);
-    }
-
-    pub fn enable_source(&mut self, source: ToolSource, cx: &mut Context<Self>) {
-        self.enabled_sources.insert(source.clone());
-
-        let tools_by_source = self.tools_by_source(cx);
-        if let Some(tools) = tools_by_source.get(&source) {
-            self.enabled_tools_by_source.insert(
-                source,
-                tools
-                    .into_iter()
-                    .map(|tool| tool.name().into())
-                    .collect::<HashSet<_>>(),
-            );
-        }
-        cx.emit(ToolWorkingSetEvent::EnabledToolsChanged);
-    }
-
-    pub fn disable_source(&mut self, source: &ToolSource, cx: &mut Context<Self>) {
-        self.enabled_sources.remove(source);
-        self.enabled_tools_by_source.remove(source);
-        cx.emit(ToolWorkingSetEvent::EnabledToolsChanged);
-    }
-
    pub fn insert(&mut self, tool: Arc<dyn Tool>) -> ToolId {
        let tool_id = self.next_tool_id;
        self.next_tool_id.0 += 1;
@@ -102,42 +58,6 @@ impl ToolWorkingSet {
        tool_id
    }

-    pub fn is_enabled(&self, source: &ToolSource, name: &Arc<str>) -> bool {
-        self.enabled_tools_by_source
-            .get(source)
-            .map_or(false, |enabled_tools| enabled_tools.contains(name))
-    }
-
-    pub fn is_disabled(&self, source: &ToolSource, name: &Arc<str>) -> bool {
-        !self.is_enabled(source, name)
-    }
-
-    pub fn enable(
-        &mut self,
-        source: ToolSource,
-        tools_to_enable: &[Arc<str>],
-        cx: &mut Context<Self>,
-    ) {
-        self.enabled_tools_by_source
-            .entry(source)
-            .or_default()
-            .extend(tools_to_enable.into_iter().cloned());
-        cx.emit(ToolWorkingSetEvent::EnabledToolsChanged);
-    }
-
-    pub fn disable(
-        &mut self,
-        source: ToolSource,
-        tools_to_disable: &[Arc<str>],
-        cx: &mut Context<Self>,
-    ) {
-        self.enabled_tools_by_source
-            .entry(source)
-            .or_default()
-            .retain(|name| !tools_to_disable.contains(name));
-        cx.emit(ToolWorkingSetEvent::EnabledToolsChanged);
-    }
-
    pub fn remove(&mut self, tool_ids_to_remove: &[ToolId]) {
        self.context_server_tools_by_id
            .retain(|id, _| !tool_ids_to_remove.contains(id));
--- a/crates/assistant_tools/Cargo.toml
+++ b/crates/assistant_tools/Cargo.toml
@@ -18,7 +18,6 @@ eval = []
 agent_settings.workspace = true
 anyhow.workspace = true
 assistant_tool.workspace = true
-async-watch.workspace = true
 buffer_diff.workspace = true
 chrono.workspace = true
 collections.workspace = true
@@ -58,6 +57,7 @@ terminal_view.workspace = true
 theme.workspace = true
 ui.workspace = true
 util.workspace = true
+watch.workspace = true
 web_search.workspace = true
 which.workspace = true
 workspace-hack.workspace = true
@@ -80,6 +80,7 @@ rand.workspace = true
 pretty_assertions.workspace = true
 reqwest_client.workspace = true
 settings = { workspace = true, features = ["test-support"] }
+smol.workspace = true
 task = { workspace = true, features = ["test-support"]}
 tempfile.workspace = true
 theme.workspace = true
--- a/crates/assistant_tools/src/edit_agent.rs
+++ b/crates/assistant_tools/src/edit_agent.rs
@@ -420,12 +420,12 @@ impl EditAgent {
        cx: &mut AsyncApp,
    ) -> (
        Task<Result<(T, Vec<ResolvedOldText>)>>,
-        async_watch::Receiver<Option<Range<usize>>>,
+        watch::Receiver<Option<Range<usize>>>,
    )
    where
        T: 'static + Send + Unpin + Stream<Item = Result<EditParserEvent>>,
    {
-        let (old_range_tx, old_range_rx) = async_watch::channel(None);
+        let (mut old_range_tx, old_range_rx) = watch::channel(None);
        let task = cx.background_spawn(async move {
            let mut matcher = StreamingFuzzyMatcher::new(snapshot);
            while let Some(edit_event) = edit_events.next().await {
--- a/crates/assistant_tools/src/edit_agent/evals.rs
+++ b/crates/assistant_tools/src/edit_agent/evals.rs
@@ -11,7 +11,7 @@ use client::{Client, UserStore};
 use collections::HashMap;
 use fs::FakeFs;
 use futures::{FutureExt, future::LocalBoxFuture};
-use gpui::{AppContext, TestAppContext};
+use gpui::{AppContext, TestAppContext, Timer};
 use indoc::{formatdoc, indoc};
 use language_model::{
    LanguageModelRegistry, LanguageModelRequestTool, LanguageModelToolResult,
@@ -39,7 +39,7 @@ fn eval_extract_handle_command_output() {
    // Model                       | Pass rate
    // ----------------------------|----------
    // claude-3.7-sonnet           |  0.98
-    // gemini-2.5-pro              |  0.86
+    // gemini-2.5-pro-06-05        |  0.77
    // gemini-2.5-flash            |  0.11
    // gpt-4.1                     |  1.00

@@ -58,6 +58,7 @@ fn eval_extract_handle_command_output() {
    eval(
        100,
        0.7, // Taking the lower bar for Gemini
+        0.05,
        EvalInput::from_conversation(
            vec![
                message(
@@ -116,6 +117,7 @@ fn eval_delete_run_git_blame() {
    eval(
        100,
        0.95,
+        0.05,
        EvalInput::from_conversation(
            vec![
                message(
@@ -178,6 +180,7 @@ fn eval_translate_doc_comments() {
    eval(
        200,
        1.,
+        0.05,
        EvalInput::from_conversation(
            vec![
                message(
@@ -241,6 +244,7 @@ fn eval_use_wasi_sdk_in_compile_parser_to_wasm() {
    eval(
        100,
        0.95,
+        0.05,
        EvalInput::from_conversation(
            vec![
                message(
@@ -365,6 +369,7 @@ fn eval_disable_cursor_blinking() {
    eval(
        100,
        0.95,
+        0.05,
        EvalInput::from_conversation(
            vec![
                message(User, [text("Let's research how to cursor blinking works.")]),
@@ -448,6 +453,9 @@ fn eval_from_pixels_constructor() {
    eval(
        100,
        0.95,
+        // For whatever reason, this eval produces more mismatched tags.
+        // Increasing for now, let's see if we can bring this down.
+        0.2,
        EvalInput::from_conversation(
            vec![
                message(
@@ -648,6 +656,7 @@ fn eval_zode() {
    eval(
        50,
        1.,
+        0.05,
        EvalInput::from_conversation(
            vec![
                message(User, [text(include_str!("evals/fixtures/zode/prompt.md"))]),
@@ -754,6 +763,7 @@ fn eval_add_overwrite_test() {
    eval(
        200,
        0.5, // TODO: make this eval better
+        0.05,
        EvalInput::from_conversation(
            vec![
                message(
@@ -993,6 +1003,7 @@ fn eval_create_empty_file() {
    eval(
        100,
        0.99,
+        0.05,
        EvalInput::from_conversation(
            vec![
                message(User, [text("Create a second empty todo file ")]),
@@ -1244,9 +1255,12 @@ impl EvalAssertion {
                }],
                ..Default::default()
            };
-            let mut response = judge
-                .stream_completion_text(request, &cx.to_async())
-                .await?;
+            let mut response = retry_on_rate_limit(async || {
+                Ok(judge
+                    .stream_completion_text(request.clone(), &cx.to_async())
+                    .await?)
+            })
+            .await?;
            let mut output = String::new();
            while let Some(chunk) = response.stream.next().await {
                let chunk = chunk?;
@@ -1279,7 +1293,12 @@ impl EvalAssertion {
    }
 }

-fn eval(iterations: usize, expected_pass_ratio: f32, mut eval: EvalInput) {
+fn eval(
+    iterations: usize,
+    expected_pass_ratio: f32,
+    mismatched_tag_threshold: f32,
+    mut eval: EvalInput,
+) {
    let mut evaluated_count = 0;
    let mut failed_count = 0;
    report_progress(evaluated_count, failed_count, iterations);
@@ -1292,10 +1311,17 @@ fn eval(iterations: usize, expected_pass_ratio: f32, mut eval: EvalInput) {
    run_eval(eval.clone(), tx.clone());

    let executor = gpui::background_executor();
+    let semaphore = Arc::new(smol::lock::Semaphore::new(32));
    for _ in 1..iterations {
        let eval = eval.clone();
        let tx = tx.clone();
-        executor.spawn(async move { run_eval(eval, tx) }).detach();
+        let semaphore = semaphore.clone();
+        executor
+            .spawn(async move {
+                let _guard = semaphore.acquire().await;
+                run_eval(eval, tx)
+            })
+            .detach();
    }
    drop(tx);

@@ -1351,7 +1377,7 @@ fn eval(iterations: usize, expected_pass_ratio: f32, mut eval: EvalInput) {

    let mismatched_tag_ratio =
        cumulative_parser_metrics.mismatched_tags as f32 / cumulative_parser_metrics.tags as f32;
-    if mismatched_tag_ratio > 0.10 {
+    if mismatched_tag_ratio > mismatched_tag_threshold {
        for eval_output in eval_outputs {
            println!("{}", eval_output);
        }
@@ -1561,21 +1587,31 @@ impl EditAgentTest {
            if let Some(input_content) = eval.input_content.as_deref() {
                buffer.update(cx, |buffer, cx| buffer.set_text(input_content, cx));
            }
-            let (edit_output, _) = self.agent.edit(
-                buffer.clone(),
-                eval.edit_file_input.display_description,
-                &conversation,
-                &mut cx.to_async(),
-            );
-            edit_output.await?
+            retry_on_rate_limit(async || {
+                self.agent
+                    .edit(
+                        buffer.clone(),
+                        eval.edit_file_input.display_description.clone(),
+                        &conversation,
+                        &mut cx.to_async(),
+                    )
+                    .0
+                    .await
+            })
+            .await?
        } else {
-            let (edit_output, _) = self.agent.overwrite(
-                buffer.clone(),
-                eval.edit_file_input.display_description,
-                &conversation,
-                &mut cx.to_async(),
-            );
-            edit_output.await?
+            retry_on_rate_limit(async || {
+                self.agent
+                    .overwrite(
+                        buffer.clone(),
+                        eval.edit_file_input.display_description.clone(),
+                        &conversation,
+                        &mut cx.to_async(),
+                    )
+                    .0
+                    .await
+            })
+            .await?
        };

        let buffer_text = buffer.read_with(cx, |buffer, _| buffer.text());
@@ -1597,6 +1633,26 @@ impl EditAgentTest {
    }
 }

+async fn retry_on_rate_limit<R>(mut request: impl AsyncFnMut() -> Result<R>) -> Result<R> {
+    loop {
+        match request().await {
+            Ok(result) => return Ok(result),
+            Err(err) => match err.downcast::<LanguageModelCompletionError>() {
+                Ok(err) => match err {
+                    LanguageModelCompletionError::RateLimit(duration) => {
+                        // Wait until after we are allowed to try again
+                        eprintln!("Rate limit exceeded. Waiting for {duration:?}...",);
+                        Timer::after(duration).await;
+                        continue;
+                    }
+                    _ => return Err(err.into()),
+                },
+                Err(err) => return Err(err),
+            },
+        }
+    }
+}
+
 #[derive(Clone, Debug, Eq, PartialEq, Hash)]
 struct EvalAssertionOutcome {
    score: usize,
--- a/crates/assistant_tools/src/edit_agent/evals/fixtures/zode/prompt.md
+++ b/crates/assistant_tools/src/edit_agent/evals/fixtures/zode/prompt.md
@@ -498,7 +498,7 @@ client.with_options(max_retries=5).messages.create(
 ### Timeouts

 By default requests time out after 10 minutes. You can configure this with a `timeout` option,
-which accepts a float or an [`httpx.Timeout`](https://www.python-httpx.org/advanced/#fine-tuning-the-configuration) object:
+which accepts a float or an [`httpx.Timeout`](https://www.python-httpx.org/advanced/timeouts/#fine-tuning-the-configuration) object:

 ```python
 from anthropic import Anthropic
--- a/crates/assistant_tools/src/terminal_tool.rs
+++ b/crates/assistant_tools/src/terminal_tool.rs
@@ -638,29 +638,36 @@ impl ToolCard for TerminalToolCard {
                            .bg(cx.theme().colors().editor_background)
                            .rounded_b_md()
                            .text_ui_sm(cx)
-                            .child(
-                                ToolOutputPreview::new(
-                                    terminal.clone().into_any_element(),
-                                    terminal.entity_id(),
-                                )
-                                .with_total_lines(self.content_line_count)
-                                .toggle_state(!terminal.read(cx).is_content_limited(window))
-                                .on_toggle({
-                                    let terminal = terminal.clone();
-                                    move |is_expanded, _, cx| {
-                                        terminal.update(cx, |terminal, cx| {
-                                            terminal.set_embedded_mode(
-                                                if is_expanded {
-                                                    None
-                                                } else {
-                                                    Some(COLLAPSED_LINES)
-                                                },
-                                                cx,
-                                            );
-                                        });
-                                    }
-                                }),
-                            ),
+                            .child({
+                                let content_mode = terminal.read(cx).content_mode(window, cx);
+
+                                if content_mode.is_scrollable() {
+                                    div().h_72().child(terminal.clone()).into_any_element()
+                                } else {
+                                    ToolOutputPreview::new(
+                                        terminal.clone().into_any_element(),
+                                        terminal.entity_id(),
+                                    )
+                                    .with_total_lines(self.content_line_count)
+                                    .toggle_state(!content_mode.is_limited())
+                                    .on_toggle({
+                                        let terminal = terminal.clone();
+                                        move |is_expanded, _, cx| {
+                                            terminal.update(cx, |terminal, cx| {
+                                                terminal.set_embedded_mode(
+                                                    if is_expanded {
+                                                        None
+                                                    } else {
+                                                        Some(COLLAPSED_LINES)
+                                                    },
+                                                    cx,
+                                                );
+                                            });
+                                        }
+                                    })
+                                    .into_any_element()
+                                }
+                            }),
                    )
                },
            )
--- a/crates/bedrock/src/models.rs
+++ b/crates/bedrock/src/models.rs
@@ -452,6 +452,10 @@ impl Model {
                | Model::Claude3_5SonnetV2
                | Model::Claude3_7Sonnet
                | Model::Claude3_7SonnetThinking
+                | Model::ClaudeSonnet4
+                | Model::ClaudeSonnet4Thinking
+                | Model::ClaudeOpus4
+                | Model::ClaudeOpus4Thinking
                | Model::Claude3Haiku
                | Model::Claude3Opus
                | Model::Claude3Sonnet
--- a/crates/channel/src/channel_store.rs
+++ b/crates/channel/src/channel_store.rs
@@ -111,7 +111,7 @@ pub struct ChannelMembership {
    pub role: proto::ChannelRole,
 }
 impl ChannelMembership {
-    pub fn sort_key(&self) -> MembershipSortKey {
+    pub fn sort_key(&self) -> MembershipSortKey<'_> {
        MembershipSortKey {
            role_order: match self.role {
                proto::ChannelRole::Admin => 0,
--- a/crates/channel/src/channel_store/channel_index.rs
+++ b/crates/channel/src/channel_store/channel_index.rs
@@ -32,7 +32,7 @@ impl ChannelIndex {
            .retain(|channel_id| !channels.contains(channel_id));
    }

-    pub fn bulk_insert(&mut self) -> ChannelPathsInsertGuard {
+    pub fn bulk_insert(&mut self) -> ChannelPathsInsertGuard<'_> {
        ChannelPathsInsertGuard {
            channels_ordered: &mut self.channels_ordered,
            channels_by_id: &mut self.channels_by_id,
--- a/crates/client/src/proxy.rs
+++ b/crates/client/src/proxy.rs
@@ -39,7 +39,7 @@ enum ProxyType<'t> {
    HttpProxy(HttpProxyType<'t>),
 }

-fn parse_proxy_type(proxy: &Url) -> Option<((String, u16), ProxyType)> {
+fn parse_proxy_type(proxy: &Url) -> Option<((String, u16), ProxyType<'_>)> {
    let scheme = proxy.scheme();
    let host = proxy.host()?.to_string();
    let port = proxy.port_or_known_default()?;
--- a/crates/collab/Cargo.toml
+++ b/crates/collab/Cargo.toml
@@ -80,7 +80,6 @@ zed_llm_client.workspace = true
 agent_settings.workspace = true
 assistant_context_editor.workspace = true
 assistant_slash_command.workspace = true
-assistant_tool.workspace = true
 async-trait.workspace = true
 audio.workspace = true
 buffer_diff.workspace = true
--- a/crates/collab/src/db/queries/channels.rs
+++ b/crates/collab/src/db/queries/channels.rs
@@ -501,8 +501,10 @@ impl Database {

    /// Returns all channels for the user with the given ID.
    pub async fn get_channels_for_user(&self, user_id: UserId) -> Result<ChannelsForUser> {
-        self.transaction(|tx| async move { self.get_user_channels(user_id, None, true, &tx).await })
-            .await
+        self.weak_transaction(
+            |tx| async move { self.get_user_channels(user_id, None, true, &tx).await },
+        )
+        .await
    }

    /// Returns all channels for the user with the given ID that are descendants
--- a/crates/collab/src/db/queries/contacts.rs
+++ b/crates/collab/src/db/queries/contacts.rs
@@ -15,7 +15,7 @@ impl Database {
            user_b_busy: bool,
        }

-        self.transaction(|tx| async move {
+        self.weak_transaction(|tx| async move {
            let user_a_participant = Alias::new("user_a_participant");
            let user_b_participant = Alias::new("user_b_participant");
            let mut db_contacts = contact::Entity::find()
@@ -91,7 +91,7 @@ impl Database {

    /// Returns whether the given user is a busy (on a call).
    pub async fn is_user_busy(&self, user_id: UserId) -> Result<bool> {
-        self.transaction(|tx| async move {
+        self.weak_transaction(|tx| async move {
            let participant = room_participant::Entity::find()
                .filter(room_participant::Column::UserId.eq(user_id))
                .one(&*tx)
--- a/crates/collab/src/db/queries/rooms.rs
+++ b/crates/collab/src/db/queries/rooms.rs
@@ -80,7 +80,7 @@ impl Database {
        &self,
        user_id: UserId,
    ) -> Result<Option<proto::IncomingCall>> {
-        self.transaction(|tx| async move {
+        self.weak_transaction(|tx| async move {
            let pending_participant = room_participant::Entity::find()
                .filter(
                    room_participant::Column::UserId
--- a/crates/collab/src/llm.rs
+++ b/crates/collab/src/llm.rs
@@ -7,6 +7,12 @@ pub use token::*;

 pub const AGENT_EXTENDED_TRIAL_FEATURE_FLAG: &str = "agent-extended-trial";

+/// The name of the feature flag that bypasses the account age check.
+pub const BYPASS_ACCOUNT_AGE_CHECK_FEATURE_FLAG: &str = "bypass-account-age-check";
+
+/// The minimum account age an account must have in order to use the LLM service.
+pub const MIN_ACCOUNT_AGE_FOR_LLM_USE: chrono::Duration = chrono::Duration::days(30);
+
 /// The default value to use for maximum spend per month if the user did not
 /// explicitly set a maximum spend.
 ///
--- a/crates/collab/src/llm/token.rs
+++ b/crates/collab/src/llm/token.rs
@@ -1,6 +1,6 @@
 use crate::db::billing_subscription::SubscriptionKind;
 use crate::db::{billing_customer, billing_subscription, user};
-use crate::llm::AGENT_EXTENDED_TRIAL_FEATURE_FLAG;
+use crate::llm::{AGENT_EXTENDED_TRIAL_FEATURE_FLAG, BYPASS_ACCOUNT_AGE_CHECK_FEATURE_FLAG};
 use crate::{Config, db::billing_preference};
 use anyhow::{Context as _, Result};
 use chrono::{NaiveDateTime, Utc};
@@ -84,7 +84,7 @@ impl LlmTokenClaims {
                .any(|flag| flag == "llm-closed-beta"),
            bypass_account_age_check: feature_flags
                .iter()
-                .any(|flag| flag == "bypass-account-age-check"),
+                .any(|flag| flag == BYPASS_ACCOUNT_AGE_CHECK_FEATURE_FLAG),
            can_use_web_search_tool: true,
            use_llm_request_queue: feature_flags.iter().any(|flag| flag == "llm-request-queue"),
            plan,
--- a/crates/collab/src/rpc.rs
+++ b/crates/collab/src/rpc.rs
@@ -4,7 +4,10 @@ use crate::api::billing::find_or_create_billing_customer;
 use crate::api::{CloudflareIpCountryHeader, SystemIdHeader};
 use crate::db::billing_subscription::SubscriptionKind;
 use crate::llm::db::LlmDatabase;
-use crate::llm::{AGENT_EXTENDED_TRIAL_FEATURE_FLAG, LlmTokenClaims};
+use crate::llm::{
+    AGENT_EXTENDED_TRIAL_FEATURE_FLAG, BYPASS_ACCOUNT_AGE_CHECK_FEATURE_FLAG, LlmTokenClaims,
+    MIN_ACCOUNT_AGE_FOR_LLM_USE,
+};
 use crate::stripe_client::StripeCustomerId;
 use crate::{
    AppState, Error, Result, auth,
@@ -65,7 +68,7 @@ use std::{
    rc::Rc,
    sync::{
        Arc, OnceLock,
-        atomic::{AtomicBool, Ordering::SeqCst},
+        atomic::{AtomicBool, AtomicUsize, Ordering::SeqCst},
    },
    time::{Duration, Instant},
 };
@@ -86,10 +89,36 @@ pub const CLEANUP_TIMEOUT: Duration = Duration::from_secs(15);
 const MESSAGE_COUNT_PER_PAGE: usize = 100;
 const MAX_MESSAGE_LEN: usize = 1024;
 const NOTIFICATION_COUNT_PER_PAGE: usize = 50;
+const MAX_CONCURRENT_CONNECTIONS: usize = 512;
+
+static CONCURRENT_CONNECTIONS: AtomicUsize = AtomicUsize::new(0);

 type MessageHandler =
    Box<dyn Send + Sync + Fn(Box<dyn AnyTypedEnvelope>, Session) -> BoxFuture<'static, ()>>;

+pub struct ConnectionGuard;
+
+impl ConnectionGuard {
+    pub fn try_acquire() -> Result<Self, ()> {
+        let current_connections = CONCURRENT_CONNECTIONS.fetch_add(1, SeqCst);
+        if current_connections >= MAX_CONCURRENT_CONNECTIONS {
+            CONCURRENT_CONNECTIONS.fetch_sub(1, SeqCst);
+            tracing::error!(
+                "too many concurrent connections: {}",
+                current_connections + 1
+            );
+            return Err(());
+        }
+        Ok(ConnectionGuard)
+    }
+}
+
+impl Drop for ConnectionGuard {
+    fn drop(&mut self) {
+        CONCURRENT_CONNECTIONS.fetch_sub(1, SeqCst);
+    }
+}
+
 struct Response<R> {
    peer: Arc<Peer>,
    receipt: Receipt<R>,
@@ -312,6 +341,7 @@ impl Server {
            .add_request_handler(
                forward_read_only_project_request::<proto::LanguageServerIdForName>,
            )
+            .add_request_handler(forward_read_only_project_request::<proto::GetDocumentDiagnostics>)
            .add_request_handler(
                forward_mutating_project_request::<proto::RegisterBufferWithLanguageServers>,
            )
@@ -354,6 +384,9 @@ impl Server {
            .add_message_handler(broadcast_project_message_from_host::<proto::BufferReloaded>)
            .add_message_handler(broadcast_project_message_from_host::<proto::BufferSaved>)
            .add_message_handler(broadcast_project_message_from_host::<proto::UpdateDiffBases>)
+            .add_message_handler(
+                broadcast_project_message_from_host::<proto::PullWorkspaceDiagnostics>,
+            )
            .add_request_handler(get_users)
            .add_request_handler(fuzzy_search_users)
            .add_request_handler(request_contact)
@@ -718,6 +751,7 @@ impl Server {
        system_id: Option<String>,
        send_connection_id: Option<oneshot::Sender<ConnectionId>>,
        executor: Executor,
+        connection_guard: Option<ConnectionGuard>,
    ) -> impl Future<Output = ()> + use<> {
        let this = self.clone();
        let span = info_span!("handle connection", %address,
@@ -738,6 +772,7 @@ impl Server {
                tracing::error!("server is tearing down");
                return
            }
+
            let (connection_id, handle_io, mut incoming_rx) = this
                .peer
                .add_connection(connection, {
@@ -779,6 +814,7 @@ impl Server {
                tracing::error!(?error, "failed to send initial client update");
                return;
            }
+            drop(connection_guard);

            let handle_io = handle_io.fuse();
            futures::pin_mut!(handle_io);
@@ -1150,6 +1186,19 @@ pub async fn handle_websocket_request(
    }

    let socket_address = socket_address.to_string();
+
+    // Acquire connection guard before WebSocket upgrade
+    let connection_guard = match ConnectionGuard::try_acquire() {
+        Ok(guard) => guard,
+        Err(()) => {
+            return (
+                StatusCode::SERVICE_UNAVAILABLE,
+                "Too many concurrent connections",
+            )
+                .into_response();
+        }
+    };
+
    ws.on_upgrade(move |socket| {
        let socket = socket
            .map_ok(to_tungstenite_message)
@@ -1167,6 +1216,7 @@ pub async fn handle_websocket_request(
                    system_id_header.map(|header| header.to_string()),
                    None,
                    Executor::Production,
+                    Some(connection_guard),
                )
                .await;
        }
@@ -2769,8 +2819,12 @@ async fn make_update_user_plan_message(
        (None, None)
    };

-    let account_too_young =
-        !matches!(plan, proto::Plan::ZedPro) && user.account_age() < MIN_ACCOUNT_AGE_FOR_LLM_USE;
+    let bypass_account_age_check = feature_flags
+        .iter()
+        .any(|flag| flag == BYPASS_ACCOUNT_AGE_CHECK_FEATURE_FLAG);
+    let account_too_young = !matches!(plan, proto::Plan::ZedPro)
+        && !bypass_account_age_check
+        && user.account_age() < MIN_ACCOUNT_AGE_FOR_LLM_USE;

    Ok(proto::UpdateUserPlan {
        plan: plan.into(),
@@ -4071,9 +4125,6 @@ async fn accept_terms_of_service(
    Ok(())
 }

-/// The minimum account age an account must have in order to use the LLM service.
-pub const MIN_ACCOUNT_AGE_FOR_LLM_USE: chrono::Duration = chrono::Duration::days(30);
-
 async fn get_llm_api_token(
    _request: proto::GetLlmToken,
    response: Response<proto::GetLlmToken>,
--- a/crates/collab/src/tests/editor_tests.rs
+++ b/crates/collab/src/tests/editor_tests.rs
@@ -7,7 +7,7 @@ use editor::{
    Editor, RowInfo,
    actions::{
        ConfirmCodeAction, ConfirmCompletion, ConfirmRename, ContextMenuFirst,
-        ExpandMacroRecursively, Redo, Rename, ToggleCodeActions, Undo,
+        ExpandMacroRecursively, Redo, Rename, SelectAll, ToggleCodeActions, Undo,
    },
    test::{
        editor_test_context::{AssertionContextManager, EditorTestContext},
@@ -2712,7 +2712,7 @@ async fn test_client_can_query_lsp_ext(cx_a: &mut TestAppContext, cx_b: &mut Tes
                params.text_document.uri,
                lsp::Url::from_file_path(path!("/a/main.rs")).unwrap(),
            );
-            assert_eq!(params.position, lsp::Position::new(0, 0),);
+            assert_eq!(params.position, lsp::Position::new(0, 0));
            Ok(Some(ExpandedMacro {
                name: "test_macro_name".to_string(),
                expansion: "test_macro_expansion on the host".to_string(),
@@ -2747,7 +2747,11 @@ async fn test_client_can_query_lsp_ext(cx_a: &mut TestAppContext, cx_b: &mut Tes
                params.text_document.uri,
                lsp::Url::from_file_path(path!("/a/main.rs")).unwrap(),
            );
-            assert_eq!(params.position, lsp::Position::new(0, 0),);
+            assert_eq!(
+                params.position,
+                lsp::Position::new(0, 12),
+                "editor_b has selected the entire text and should query for a different position"
+            );
            Ok(Some(ExpandedMacro {
                name: "test_macro_name".to_string(),
                expansion: "test_macro_expansion on the client".to_string(),
@@ -2756,6 +2760,7 @@ async fn test_client_can_query_lsp_ext(cx_a: &mut TestAppContext, cx_b: &mut Tes
    );

    editor_b.update_in(cx_b, |editor, window, cx| {
+        editor.select_all(&SelectAll, window, cx);
        expand_macro_recursively(editor, &ExpandMacroRecursively, window, cx)
    });
    expand_request_b.next().await.unwrap();
--- a/crates/collab/src/tests/integration_tests.rs
+++ b/crates/collab/src/tests/integration_tests.rs
@@ -20,8 +20,8 @@ use gpui::{
    UpdateGlobal, px, size,
 };
 use language::{
-    Diagnostic, DiagnosticEntry, FakeLspAdapter, Language, LanguageConfig, LanguageMatcher,
-    LineEnding, OffsetRangeExt, Point, Rope,
+    Diagnostic, DiagnosticEntry, DiagnosticSourceKind, FakeLspAdapter, Language, LanguageConfig,
+    LanguageMatcher, LineEnding, OffsetRangeExt, Point, Rope,
    language_settings::{
        AllLanguageSettings, Formatter, FormatterList, PrettierSettings, SelectedFormatter,
    },
@@ -4237,7 +4237,8 @@ async fn test_collaborating_with_diagnostics(
                        message: "message 1".to_string(),
                        severity: lsp::DiagnosticSeverity::ERROR,
                        is_primary: true,
-                        ..Default::default()
+                        source_kind: DiagnosticSourceKind::Pushed,
+                        ..Diagnostic::default()
                    }
                },
                DiagnosticEntry {
@@ -4247,7 +4248,8 @@ async fn test_collaborating_with_diagnostics(
                        severity: lsp::DiagnosticSeverity::WARNING,
                        message: "message 2".to_string(),
                        is_primary: true,
-                        ..Default::default()
+                        source_kind: DiagnosticSourceKind::Pushed,
+                        ..Diagnostic::default()
                    }
                }
            ]
@@ -4259,7 +4261,7 @@ async fn test_collaborating_with_diagnostics(
        &lsp::PublishDiagnosticsParams {
            uri: lsp::Url::from_file_path(path!("/a/a.rs")).unwrap(),
            version: None,
-            diagnostics: vec![],
+            diagnostics: Vec::new(),
        },
    );
    executor.run_until_parked();
--- a/crates/collab/src/tests/remote_editing_collaboration_tests.rs
+++ b/crates/collab/src/tests/remote_editing_collaboration_tests.rs
@@ -671,7 +671,7 @@ async fn test_remote_server_debugger(
    });

    session.update(cx_a, |session, _| {
-        assert_eq!(session.binary().command, "ssh");
+        assert_eq!(session.binary().command.as_deref(), Some("ssh"));
    });

    let shutdown_session = workspace.update(cx_a, |workspace, cx| {
--- a/crates/collab/src/tests/test_server.rs
+++ b/crates/collab/src/tests/test_server.rs
@@ -258,6 +258,7 @@ impl TestServer {
                            None,
                            Some(connection_id_tx),
                            Executor::Deterministic(cx.background_executor().clone()),
+                            None,
                        ))
                        .detach();
                        let connection_id = connection_id_rx.await.map_err(|e| {
--- a/crates/collab_ui/src/chat_panel/message_editor.rs
+++ b/crates/collab_ui/src/chat_panel/message_editor.rs
@@ -15,7 +15,6 @@ use language::{
 use project::{Completion, CompletionResponse, CompletionSource, search::SearchQuery};
 use settings::Settings;
 use std::{
-    cell::RefCell,
    ops::Range,
    rc::Rc,
    sync::{Arc, LazyLock},
@@ -73,16 +72,6 @@ impl CompletionProvider for MessageEditorCompletionProvider {
        })
    }

-    fn resolve_completions(
-        &self,
-        _buffer: Entity<Buffer>,
-        _completion_indices: Vec<usize>,
-        _completions: Rc<RefCell<Box<[Completion]>>>,
-        _cx: &mut Context<Editor>,
-    ) -> Task<anyhow::Result<bool>> {
-        Task::ready(Ok(false))
-    }
-
    fn is_completion_trigger(
        &self,
        _buffer: &Entity<Buffer>,
@@ -255,7 +244,7 @@ impl MessageEditor {
        {
            if !candidates.is_empty() {
                return cx.spawn(async move |_, cx| {
-                    let completion_response = Self::resolve_completions_for_candidates(
+                    let completion_response = Self::completions_for_candidates(
                        &cx,
                        query.as_str(),
                        &candidates,
@@ -273,7 +262,7 @@ impl MessageEditor {
        {
            if !candidates.is_empty() {
                return cx.spawn(async move |_, cx| {
-                    let completion_response = Self::resolve_completions_for_candidates(
+                    let completion_response = Self::completions_for_candidates(
                        &cx,
                        query.as_str(),
                        candidates,
@@ -292,7 +281,7 @@ impl MessageEditor {
        }]))
    }

-    async fn resolve_completions_for_candidates(
+    async fn completions_for_candidates(
        cx: &AsyncApp,
        query: &str,
        candidates: &[StringMatchCandidate],
--- a/crates/context_server/Cargo.toml
+++ b/crates/context_server/Cargo.toml
@@ -11,6 +11,9 @@ workspace = true
 [lib]
 path = "src/context_server.rs"

+[features]
+test-support = []
+
 [dependencies]
 anyhow.workspace = true
 async-trait.workspace = true
--- a/crates/context_server/src/context_server.rs
+++ b/crates/context_server/src/context_server.rs
@@ -1,5 +1,7 @@
 pub mod client;
 pub mod protocol;
+#[cfg(any(test, feature = "test-support"))]
+pub mod test;
 pub mod transport;
 pub mod types;

--- a/crates/context_server/src/protocol.rs
+++ b/crates/context_server/src/protocol.rs
@@ -6,10 +6,9 @@
 //! of messages.

 use anyhow::Result;
-use collections::HashMap;

 use crate::client::Client;
-use crate::types;
+use crate::types::{self, Notification, Request};

 pub struct ModelContextProtocol {
    inner: Client,
@@ -21,9 +20,10 @@ impl ModelContextProtocol {
    }

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

    pub async fn initialize(
@@ -43,7 +43,7 @@ impl ModelContextProtocol {

        let response: types::InitializeResponse = self
            .inner
-            .request(types::RequestType::Initialize.as_str(), params)
+            .request(types::requests::Initialize::METHOD, params)
            .await?;

        anyhow::ensure!(
@@ -54,16 +54,13 @@ impl ModelContextProtocol {

        log::trace!("mcp server info {:?}", response.server_info);

-        self.inner.notify(
-            types::NotificationType::Initialized.as_str(),
-            serde_json::json!({}),
-        )?;
-
        let initialized_protocol = InitializedContextServerProtocol {
            inner: self.inner,
            initialize: response,
        };

+        initialized_protocol.notify::<types::notifications::Initialized>(())?;
+
        Ok(initialized_protocol)
    }
 }
@@ -94,137 +91,11 @@ impl InitializedContextServerProtocol {
        }
    }

-    fn check_capability(&self, capability: ServerCapability) -> Result<()> {
-        anyhow::ensure!(
-            self.capable(capability),
-            "Server does not support {capability:?} capability"
-        );
-        Ok(())
+    pub async fn request<T: Request>(&self, params: T::Params) -> Result<T::Response> {
+        self.inner.request(T::METHOD, params).await
    }

-    /// List the MCP prompts.
-    pub async fn list_prompts(&self) -> Result<Vec<types::Prompt>> {
-        self.check_capability(ServerCapability::Prompts)?;
-
-        let response: types::PromptsListResponse = self
-            .inner
-            .request(
-                types::RequestType::PromptsList.as_str(),
-                serde_json::json!({}),
-            )
-            .await?;
-
-        Ok(response.prompts)
-    }
-
-    /// List the MCP resources.
-    pub async fn list_resources(&self) -> Result<types::ResourcesListResponse> {
-        self.check_capability(ServerCapability::Resources)?;
-
-        let response: types::ResourcesListResponse = self
-            .inner
-            .request(
-                types::RequestType::ResourcesList.as_str(),
-                serde_json::json!({}),
-            )
-            .await?;
-
-        Ok(response)
-    }
-
-    /// Executes a prompt with the given arguments and returns the result.
-    pub async fn run_prompt<P: AsRef<str>>(
-        &self,
-        prompt: P,
-        arguments: HashMap<String, String>,
-    ) -> Result<types::PromptsGetResponse> {
-        self.check_capability(ServerCapability::Prompts)?;
-
-        let params = types::PromptsGetParams {
-            name: prompt.as_ref().to_string(),
-            arguments: Some(arguments),
-            meta: None,
-        };
-
-        let response: types::PromptsGetResponse = self
-            .inner
-            .request(types::RequestType::PromptsGet.as_str(), params)
-            .await?;
-
-        Ok(response)
-    }
-
-    pub async fn completion<P: Into<String>>(
-        &self,
-        reference: types::CompletionReference,
-        argument: P,
-        value: P,
-    ) -> Result<types::Completion> {
-        let params = types::CompletionCompleteParams {
-            r#ref: reference,
-            argument: types::CompletionArgument {
-                name: argument.into(),
-                value: value.into(),
-            },
-            meta: None,
-        };
-        let result: types::CompletionCompleteResponse = self
-            .inner
-            .request(types::RequestType::CompletionComplete.as_str(), params)
-            .await?;
-
-        let completion = types::Completion {
-            values: result.completion.values,
-            total: types::CompletionTotal::from_options(
-                result.completion.has_more,
-                result.completion.total,
-            ),
-        };
-
-        Ok(completion)
-    }
-
-    /// List MCP tools.
-    pub async fn list_tools(&self) -> Result<types::ListToolsResponse> {
-        self.check_capability(ServerCapability::Tools)?;
-
-        let response = self
-            .inner
-            .request::<types::ListToolsResponse>(types::RequestType::ListTools.as_str(), ())
-            .await?;
-
-        Ok(response)
-    }
-
-    /// Executes a tool with the given arguments
-    pub async fn run_tool<P: AsRef<str>>(
-        &self,
-        tool: P,
-        arguments: Option<HashMap<String, serde_json::Value>>,
-    ) -> Result<types::CallToolResponse> {
-        self.check_capability(ServerCapability::Tools)?;
-
-        let params = types::CallToolParams {
-            name: tool.as_ref().to_string(),
-            arguments,
-            meta: None,
-        };
-
-        let response: types::CallToolResponse = self
-            .inner
-            .request(types::RequestType::CallTool.as_str(), params)
-            .await?;
-
-        Ok(response)
-    }
-}
-
-impl InitializedContextServerProtocol {
-    pub async fn request<R: serde::de::DeserializeOwned>(
-        &self,
-        method: &str,
-        params: impl serde::Serialize,
-    ) -> Result<R> {
-        self.inner.request(method, params).await
+    pub fn notify<T: Notification>(&self, params: T::Params) -> Result<()> {
+        self.inner.notify(T::METHOD, params)
    }
 }
--- a/crates/context_server/src/test.rs
+++ b/crates/context_server/src/test.rs
@@ -0,0 +1,118 @@
+use anyhow::Context as _;
+use collections::HashMap;
+use futures::{Stream, StreamExt as _, lock::Mutex};
+use gpui::BackgroundExecutor;
+use std::{pin::Pin, sync::Arc};
+
+use crate::{
+    transport::Transport,
+    types::{Implementation, InitializeResponse, ProtocolVersion, ServerCapabilities},
+};
+
+pub fn create_fake_transport(
+    name: impl Into<String>,
+    executor: BackgroundExecutor,
+) -> FakeTransport {
+    let name = name.into();
+    FakeTransport::new(executor).on_request::<crate::types::requests::Initialize>(move |_params| {
+        create_initialize_response(name.clone())
+    })
+}
+
+fn create_initialize_response(server_name: String) -> InitializeResponse {
+    InitializeResponse {
+        protocol_version: ProtocolVersion(crate::types::LATEST_PROTOCOL_VERSION.to_string()),
+        server_info: Implementation {
+            name: server_name,
+            version: "1.0.0".to_string(),
+        },
+        capabilities: ServerCapabilities::default(),
+        meta: None,
+    }
+}
+
+pub struct FakeTransport {
+    request_handlers:
+        HashMap<&'static str, Arc<dyn Fn(serde_json::Value) -> serde_json::Value + Send + Sync>>,
+    tx: futures::channel::mpsc::UnboundedSender<String>,
+    rx: Arc<Mutex<futures::channel::mpsc::UnboundedReceiver<String>>>,
+    executor: BackgroundExecutor,
+}
+
+impl FakeTransport {
+    pub fn new(executor: BackgroundExecutor) -> Self {
+        let (tx, rx) = futures::channel::mpsc::unbounded();
+        Self {
+            request_handlers: Default::default(),
+            tx,
+            rx: Arc::new(Mutex::new(rx)),
+            executor,
+        }
+    }
+
+    pub fn on_request<T: crate::types::Request>(
+        mut self,
+        handler: impl Fn(T::Params) -> T::Response + Send + Sync + 'static,
+    ) -> Self {
+        self.request_handlers.insert(
+            T::METHOD,
+            Arc::new(move |value| {
+                let params = value.get("params").expect("Missing parameters").clone();
+                let params: T::Params =
+                    serde_json::from_value(params).expect("Invalid parameters received");
+                let response = handler(params);
+                serde_json::to_value(response).unwrap()
+            }),
+        );
+        self
+    }
+}
+
+#[async_trait::async_trait]
+impl Transport for FakeTransport {
+    async fn send(&self, message: String) -> anyhow::Result<()> {
+        if let Ok(msg) = serde_json::from_str::<serde_json::Value>(&message) {
+            let id = msg.get("id").and_then(|id| id.as_u64()).unwrap_or(0);
+
+            if let Some(method) = msg.get("method") {
+                let method = method.as_str().expect("Invalid method received");
+                if let Some(handler) = self.request_handlers.get(method) {
+                    let payload = handler(msg);
+                    let response = serde_json::json!({
+                        "jsonrpc": "2.0",
+                        "id": id,
+                        "result": payload
+                    });
+                    self.tx
+                        .unbounded_send(response.to_string())
+                        .context("sending a message")?;
+                } else {
+                    log::debug!("No handler registered for MCP request '{method}'");
+                }
+            }
+        }
+        Ok(())
+    }
+
+    fn receive(&self) -> Pin<Box<dyn Stream<Item = String> + Send>> {
+        let rx = self.rx.clone();
+        let executor = self.executor.clone();
+        Box::pin(futures::stream::unfold(rx, move |rx| {
+            let executor = executor.clone();
+            async move {
+                let mut rx_guard = rx.lock().await;
+                executor.simulate_random_delay().await;
+                if let Some(message) = rx_guard.next().await {
+                    drop(rx_guard);
+                    Some((message, rx))
+                } else {
+                    None
+                }
+            }
+        }))
+    }
+
+    fn receive_err(&self) -> Pin<Box<dyn Stream<Item = String> + Send>> {
+        Box::pin(futures::stream::empty())
+    }
+}
--- a/crates/context_server/src/types.rs
+++ b/crates/context_server/src/types.rs
@@ -1,76 +1,144 @@
 use collections::HashMap;
+use serde::de::DeserializeOwned;
 use serde::{Deserialize, Serialize};
 use url::Url;

-pub const LATEST_PROTOCOL_VERSION: &str = "2024-11-05";
+pub const LATEST_PROTOCOL_VERSION: &str = "2025-03-26";
+pub const VERSION_2024_11_05: &str = "2024-11-05";

-pub enum RequestType {
-    Initialize,
-    CallTool,
-    ResourcesUnsubscribe,
-    ResourcesSubscribe,
-    ResourcesRead,
-    ResourcesList,
-    LoggingSetLevel,
-    PromptsGet,
-    PromptsList,
-    CompletionComplete,
-    Ping,
-    ListTools,
-    ListResourceTemplates,
-    ListRoots,
+pub mod requests {
+    use super::*;
+
+    macro_rules! request {
+        ($method:expr, $name:ident, $params:ty, $response:ty) => {
+            pub struct $name;
+
+            impl Request for $name {
+                type Params = $params;
+                type Response = $response;
+                const METHOD: &'static str = $method;
+            }
+        };
+    }
+
+    request!(
+        "initialize",
+        Initialize,
+        InitializeParams,
+        InitializeResponse
+    );
+    request!("tools/call", CallTool, CallToolParams, CallToolResponse);
+    request!(
+        "resources/unsubscribe",
+        ResourcesUnsubscribe,
+        ResourcesUnsubscribeParams,
+        ()
+    );
+    request!(
+        "resources/subscribe",
+        ResourcesSubscribe,
+        ResourcesSubscribeParams,
+        ()
+    );
+    request!(
+        "resources/read",
+        ResourcesRead,
+        ResourcesReadParams,
+        ResourcesReadResponse
+    );
+    request!("resources/list", ResourcesList, (), ResourcesListResponse);
+    request!(
+        "logging/setLevel",
+        LoggingSetLevel,
+        LoggingSetLevelParams,
+        ()
+    );
+    request!(
+        "prompts/get",
+        PromptsGet,
+        PromptsGetParams,
+        PromptsGetResponse
+    );
+    request!("prompts/list", PromptsList, (), PromptsListResponse);
+    request!(
+        "completion/complete",
+        CompletionComplete,
+        CompletionCompleteParams,
+        CompletionCompleteResponse
+    );
+    request!("ping", Ping, (), ());
+    request!("tools/list", ListTools, (), ListToolsResponse);
+    request!(
+        "resources/templates/list",
+        ListResourceTemplates,
+        (),
+        ListResourceTemplatesResponse
+    );
+    request!("roots/list", ListRoots, (), ListRootsResponse);
 }

-impl RequestType {
-    pub fn as_str(&self) -> &'static str {
-        match self {
-            RequestType::Initialize => "initialize",
-            RequestType::CallTool => "tools/call",
-            RequestType::ResourcesUnsubscribe => "resources/unsubscribe",
-            RequestType::ResourcesSubscribe => "resources/subscribe",
-            RequestType::ResourcesRead => "resources/read",
-            RequestType::ResourcesList => "resources/list",
-            RequestType::LoggingSetLevel => "logging/setLevel",
-            RequestType::PromptsGet => "prompts/get",
-            RequestType::PromptsList => "prompts/list",
-            RequestType::CompletionComplete => "completion/complete",
-            RequestType::Ping => "ping",
-            RequestType::ListTools => "tools/list",
-            RequestType::ListResourceTemplates => "resources/templates/list",
-            RequestType::ListRoots => "roots/list",
-        }
-    }
+pub trait Request {
+    type Params: DeserializeOwned + Serialize + Send + Sync + 'static;
+    type Response: DeserializeOwned + Serialize + Send + Sync + 'static;
+    const METHOD: &'static str;
 }

-impl TryFrom<&str> for RequestType {
-    type Error = ();
+pub mod notifications {
+    use super::*;

-    fn try_from(s: &str) -> Result<Self, Self::Error> {
-        match s {
-            "initialize" => Ok(RequestType::Initialize),
-            "tools/call" => Ok(RequestType::CallTool),
-            "resources/unsubscribe" => Ok(RequestType::ResourcesUnsubscribe),
-            "resources/subscribe" => Ok(RequestType::ResourcesSubscribe),
-            "resources/read" => Ok(RequestType::ResourcesRead),
-            "resources/list" => Ok(RequestType::ResourcesList),
-            "logging/setLevel" => Ok(RequestType::LoggingSetLevel),
-            "prompts/get" => Ok(RequestType::PromptsGet),
-            "prompts/list" => Ok(RequestType::PromptsList),
-            "completion/complete" => Ok(RequestType::CompletionComplete),
-            "ping" => Ok(RequestType::Ping),
-            "tools/list" => Ok(RequestType::ListTools),
-            "resources/templates/list" => Ok(RequestType::ListResourceTemplates),
-            "roots/list" => Ok(RequestType::ListRoots),
-            _ => Err(()),
-        }
+    macro_rules! notification {
+        ($method:expr, $name:ident, $params:ty) => {
+            pub struct $name;
+
+            impl Notification for $name {
+                type Params = $params;
+                const METHOD: &'static str = $method;
+            }
+        };
    }
+
+    notification!("notifications/initialized", Initialized, ());
+    notification!("notifications/progress", Progress, ProgressParams);
+    notification!("notifications/message", Message, MessageParams);
+    notification!(
+        "notifications/resources/updated",
+        ResourcesUpdated,
+        ResourcesUpdatedParams
+    );
+    notification!(
+        "notifications/resources/list_changed",
+        ResourcesListChanged,
+        ()
+    );
+    notification!("notifications/tools/list_changed", ToolsListChanged, ());
+    notification!("notifications/prompts/list_changed", PromptsListChanged, ());
+    notification!("notifications/roots/list_changed", RootsListChanged, ());
+}
+
+pub trait Notification {
+    type Params: DeserializeOwned + Serialize + Send + Sync + 'static;
+    const METHOD: &'static str;
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct MessageParams {
+    pub level: LoggingLevel,
+    pub logger: Option<String>,
+    pub data: serde_json::Value,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ResourcesUpdatedParams {
+    pub uri: String,
 }

 #[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(transparent)]
 pub struct ProtocolVersion(pub String);

-#[derive(Debug, Serialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct InitializeParams {
    pub protocol_version: ProtocolVersion,
@@ -80,7 +148,7 @@ pub struct InitializeParams {
    pub meta: Option<HashMap<String, serde_json::Value>>,
 }

-#[derive(Debug, Serialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct CallToolParams {
    pub name: String,
@@ -90,7 +158,7 @@ pub struct CallToolParams {
    pub meta: Option<HashMap<String, serde_json::Value>>,
 }

-#[derive(Debug, Serialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ResourcesUnsubscribeParams {
    pub uri: Url,
@@ -98,7 +166,7 @@ pub struct ResourcesUnsubscribeParams {
    pub meta: Option<HashMap<String, serde_json::Value>>,
 }

-#[derive(Debug, Serialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ResourcesSubscribeParams {
    pub uri: Url,
@@ -106,7 +174,7 @@ pub struct ResourcesSubscribeParams {
    pub meta: Option<HashMap<String, serde_json::Value>>,
 }

-#[derive(Debug, Serialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ResourcesReadParams {
    pub uri: Url,
@@ -114,7 +182,7 @@ pub struct ResourcesReadParams {
    pub meta: Option<HashMap<String, serde_json::Value>>,
 }

-#[derive(Debug, Serialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct LoggingSetLevelParams {
    pub level: LoggingLevel,
@@ -122,7 +190,7 @@ pub struct LoggingSetLevelParams {
    pub meta: Option<HashMap<String, serde_json::Value>>,
 }

-#[derive(Debug, Serialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct PromptsGetParams {
    pub name: String,
@@ -132,37 +200,40 @@ pub struct PromptsGetParams {
    pub meta: Option<HashMap<String, serde_json::Value>>,
 }

-#[derive(Debug, Serialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct CompletionCompleteParams {
-    pub r#ref: CompletionReference,
+    #[serde(rename = "ref")]
+    pub reference: CompletionReference,
    pub argument: CompletionArgument,
    #[serde(rename = "_meta", skip_serializing_if = "Option::is_none")]
    pub meta: Option<HashMap<String, serde_json::Value>>,
 }

-#[derive(Debug, Serialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(untagged)]
 pub enum CompletionReference {
    Prompt(PromptReference),
    Resource(ResourceReference),
 }

-#[derive(Debug, Serialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct PromptReference {
-    pub r#type: PromptReferenceType,
+    #[serde(rename = "type")]
+    pub ty: PromptReferenceType,
    pub name: String,
 }

-#[derive(Debug, Serialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ResourceReference {
-    pub r#type: PromptReferenceType,
+    #[serde(rename = "type")]
+    pub ty: PromptReferenceType,
    pub uri: Url,
 }

-#[derive(Debug, Serialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum PromptReferenceType {
    #[serde(rename = "ref/prompt")]
@@ -171,7 +242,7 @@ pub enum PromptReferenceType {
    Resource,
 }

-#[derive(Debug, Serialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct CompletionArgument {
    pub name: String,
@@ -188,7 +259,7 @@ pub struct InitializeResponse {
    pub meta: Option<HashMap<String, serde_json::Value>>,
 }

-#[derive(Debug, Deserialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ResourcesReadResponse {
    pub contents: Vec<ResourceContentsType>,
@@ -196,14 +267,14 @@ pub struct ResourcesReadResponse {
    pub meta: Option<HashMap<String, serde_json::Value>>,
 }

-#[derive(Debug, Deserialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(untagged)]
 pub enum ResourceContentsType {
    Text(TextResourceContents),
    Blob(BlobResourceContents),
 }

-#[derive(Debug, Deserialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ResourcesListResponse {
    pub resources: Vec<Resource>,
@@ -220,7 +291,7 @@ pub struct SamplingMessage {
    pub content: MessageContent,
 }

-#[derive(Debug, Serialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct CreateMessageRequest {
    pub messages: Vec<SamplingMessage>,
@@ -272,13 +343,20 @@ pub enum MessageContent {
        #[serde(skip_serializing_if = "Option::is_none")]
        annotations: Option<MessageAnnotations>,
    },
-    #[serde(rename = "image")]
+    #[serde(rename = "image", rename_all = "camelCase")]
    Image {
        data: String,
        mime_type: String,
        #[serde(skip_serializing_if = "Option::is_none")]
        annotations: Option<MessageAnnotations>,
    },
+    #[serde(rename = "audio", rename_all = "camelCase")]
+    Audio {
+        data: String,
+        mime_type: String,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        annotations: Option<MessageAnnotations>,
+    },
    #[serde(rename = "resource")]
    Resource {
        resource: ResourceContents,
@@ -296,7 +374,7 @@ pub struct MessageAnnotations {
    pub priority: Option<f64>,
 }

-#[derive(Debug, Deserialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct PromptsGetResponse {
    #[serde(skip_serializing_if = "Option::is_none")]
@@ -306,7 +384,7 @@ pub struct PromptsGetResponse {
    pub meta: Option<HashMap<String, serde_json::Value>>,
 }

-#[derive(Debug, Deserialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct PromptsListResponse {
    pub prompts: Vec<Prompt>,
@@ -316,7 +394,7 @@ pub struct PromptsListResponse {
    pub meta: Option<HashMap<String, serde_json::Value>>,
 }

-#[derive(Debug, Deserialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct CompletionCompleteResponse {
    pub completion: CompletionResult,
@@ -324,7 +402,7 @@ pub struct CompletionCompleteResponse {
    pub meta: Option<HashMap<String, serde_json::Value>>,
 }

-#[derive(Debug, Deserialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct CompletionResult {
    pub values: Vec<String>,
@@ -336,7 +414,7 @@ pub struct CompletionResult {
    pub meta: Option<HashMap<String, serde_json::Value>>,
 }

-#[derive(Debug, Deserialize, Serialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct Prompt {
    pub name: String,
@@ -346,7 +424,7 @@ pub struct Prompt {
    pub arguments: Option<Vec<PromptArgument>>,
 }

-#[derive(Debug, Deserialize, Serialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct PromptArgument {
    pub name: String,
@@ -375,6 +453,8 @@ pub struct ServerCapabilities {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub logging: Option<serde_json::Value>,
    #[serde(skip_serializing_if = "Option::is_none")]
+    pub completions: Option<serde_json::Value>,
+    #[serde(skip_serializing_if = "Option::is_none")]
    pub prompts: Option<PromptsCapabilities>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub resources: Option<ResourcesCapabilities>,
@@ -419,6 +499,28 @@ pub struct Tool {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    pub input_schema: serde_json::Value,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub annotations: Option<ToolAnnotations>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ToolAnnotations {
+    /// A human-readable title for the tool.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub title: Option<String>,
+    /// If true, the tool does not modify its environment.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub read_only_hint: Option<bool>,
+    /// If true, the tool may perform destructive updates to its environment.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub destructive_hint: Option<bool>,
+    /// If true, calling the tool repeatedly with the same arguments will have no additional effect on its environment.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub idempotent_hint: Option<bool>,
+    /// If true, this tool may interact with an "open world" of external entities.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub open_world_hint: Option<bool>,
 }

 #[derive(Debug, Serialize, Deserialize)]
@@ -509,34 +611,6 @@ pub struct ModelHint {
    pub name: Option<String>,
 }

-#[derive(Debug, Serialize)]
-#[serde(rename_all = "camelCase")]
-pub enum NotificationType {
-    Initialized,
-    Progress,
-    Message,
-    ResourcesUpdated,
-    ResourcesListChanged,
-    ToolsListChanged,
-    PromptsListChanged,
-    RootsListChanged,
-}
-
-impl NotificationType {
-    pub fn as_str(&self) -> &'static str {
-        match self {
-            NotificationType::Initialized => "notifications/initialized",
-            NotificationType::Progress => "notifications/progress",
-            NotificationType::Message => "notifications/message",
-            NotificationType::ResourcesUpdated => "notifications/resources/updated",
-            NotificationType::ResourcesListChanged => "notifications/resources/list_changed",
-            NotificationType::ToolsListChanged => "notifications/tools/list_changed",
-            NotificationType::PromptsListChanged => "notifications/prompts/list_changed",
-            NotificationType::RootsListChanged => "notifications/roots/list_changed",
-        }
-    }
-}
-
 #[derive(Debug, Serialize)]
 #[serde(untagged)]
 pub enum ClientNotification {
@@ -557,12 +631,14 @@ pub enum ProgressToken {
    Number(f64),
 }

-#[derive(Debug, Serialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ProgressParams {
    pub progress_token: ProgressToken,
    pub progress: f64,
    #[serde(skip_serializing_if = "Option::is_none")]
+    pub message: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
    pub total: Option<f64>,
    #[serde(rename = "_meta", skip_serializing_if = "Option::is_none")]
    pub meta: Option<HashMap<String, serde_json::Value>>,
@@ -589,7 +665,7 @@ pub struct Completion {
    pub total: CompletionTotal,
 }

-#[derive(Debug, Deserialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct CallToolResponse {
    pub content: Vec<ToolResponseContent>,
@@ -606,6 +682,8 @@ pub enum ToolResponseContent {
    Text { text: String },
    #[serde(rename = "image", rename_all = "camelCase")]
    Image { data: String, mime_type: String },
+    #[serde(rename = "audio", rename_all = "camelCase")]
+    Audio { data: String, mime_type: String },
    #[serde(rename = "resource")]
    Resource { resource: ResourceContents },
 }
@@ -620,7 +698,7 @@ pub struct ListToolsResponse {
    pub meta: Option<HashMap<String, serde_json::Value>>,
 }

-#[derive(Debug, Deserialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ListResourceTemplatesResponse {
    pub resource_templates: Vec<ResourceTemplate>,
@@ -630,7 +708,7 @@ pub struct ListResourceTemplatesResponse {
    pub meta: Option<HashMap<String, serde_json::Value>>,
 }

-#[derive(Debug, Deserialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ListRootsResponse {
    pub roots: Vec<Root>,
--- a/crates/copilot/src/copilot.rs
+++ b/crates/copilot/src/copilot.rs
@@ -408,24 +408,30 @@ impl Copilot {
        let proxy_url = copilot_settings.proxy.clone()?;
        let no_verify = copilot_settings.proxy_no_verify;
        let http_or_https_proxy = if proxy_url.starts_with("http:") {
-            "HTTP_PROXY"
+            Some("HTTP_PROXY")
        } else if proxy_url.starts_with("https:") {
-            "HTTPS_PROXY"
+            Some("HTTPS_PROXY")
        } else {
            log::error!(
                "Unsupported protocol scheme for language server proxy (must be http or https)"
            );
-            return None;
+            None
        };

        let mut env = HashMap::default();
-        env.insert(http_or_https_proxy.to_string(), proxy_url);

-        if let Some(true) = no_verify {
-            env.insert("NODE_TLS_REJECT_UNAUTHORIZED".to_string(), "0".to_string());
-        };
+        if let Some(proxy_type) = http_or_https_proxy {
+            env.insert(proxy_type.to_string(), proxy_url);
+            if let Some(true) = no_verify {
+                env.insert("NODE_TLS_REJECT_UNAUTHORIZED".to_string(), "0".to_string());
+            };
+        }

-        Some(env)
+        if let Ok(oauth_token) = env::var(copilot_chat::COPILOT_OAUTH_ENV_VAR) {
+            env.insert(copilot_chat::COPILOT_OAUTH_ENV_VAR.to_string(), oauth_token);
+        }
+
+        if env.is_empty() { None } else { Some(env) }
    }

    #[cfg(any(test, feature = "test-support"))]
@@ -520,7 +526,7 @@ impl Copilot {

            let server = cx
                .update(|cx| {
-                    let mut params = server.default_initialize_params(cx);
+                    let mut params = server.default_initialize_params(false, cx);
                    params.initialization_options = Some(editor_info_json);
                    server.initialize(params, configuration.into(), cx)
                })?
--- a/crates/copilot/src/copilot_chat.rs
+++ b/crates/copilot/src/copilot_chat.rs
@@ -8,6 +8,7 @@ use chrono::DateTime;
 use collections::HashSet;
 use fs::Fs;
 use futures::{AsyncBufReadExt, AsyncReadExt, StreamExt, io::BufReader, stream::BoxStream};
+use gpui::WeakEntity;
 use gpui::{App, AsyncApp, Global, prelude::*};
 use http_client::{AsyncBody, HttpClient, Method, Request as HttpRequest};
 use itertools::Itertools;
@@ -15,9 +16,14 @@ use paths::home_dir;
 use serde::{Deserialize, Serialize};
 use settings::watch_config_dir;

-pub const COPILOT_CHAT_COMPLETION_URL: &str = "https://api.githubcopilot.com/chat/completions";
-pub const COPILOT_CHAT_AUTH_URL: &str = "https://api.github.com/copilot_internal/v2/token";
-pub const COPILOT_CHAT_MODELS_URL: &str = "https://api.githubcopilot.com/models";
+pub const COPILOT_OAUTH_ENV_VAR: &str = "GH_COPILOT_TOKEN";
+
+#[derive(Default, Clone, Debug, PartialEq)]
+pub struct CopilotChatSettings {
+    pub api_url: Arc<str>,
+    pub auth_url: Arc<str>,
+    pub models_url: Arc<str>,
+}

 // Copilot's base model; defined by Microsoft in premium requests table
 // This will be moved to the front of the Copilot model list, and will be used for
@@ -340,6 +346,7 @@ impl Global for GlobalCopilotChat {}
 pub struct CopilotChat {
    oauth_token: Option<String>,
    api_token: Option<ApiToken>,
+    settings: CopilotChatSettings,
    models: Option<Vec<Model>>,
    client: Arc<dyn HttpClient>,
 }
@@ -373,62 +380,77 @@ impl CopilotChat {
            .map(|model| model.0.clone())
    }

-    pub fn new(fs: Arc<dyn Fs>, client: Arc<dyn HttpClient>, cx: &App) -> Self {
+    fn new(fs: Arc<dyn Fs>, client: Arc<dyn HttpClient>, cx: &mut Context<Self>) -> Self {
        let config_paths: HashSet<PathBuf> = copilot_chat_config_paths().into_iter().collect();
        let dir_path = copilot_chat_config_dir();
+        let settings = CopilotChatSettings::default();
+        cx.spawn(async move |this, cx| {
+            let mut parent_watch_rx = watch_config_dir(
+                cx.background_executor(),
+                fs.clone(),
+                dir_path.clone(),
+                config_paths,
+            );
+            while let Some(contents) = parent_watch_rx.next().await {
+                let oauth_token = extract_oauth_token(contents);

-        cx.spawn({
-            let client = client.clone();
-            async move |cx| {
-                let mut parent_watch_rx = watch_config_dir(
-                    cx.background_executor(),
-                    fs.clone(),
-                    dir_path.clone(),
-                    config_paths,
-                );
-                while let Some(contents) = parent_watch_rx.next().await {
-                    let oauth_token = extract_oauth_token(contents);
-                    cx.update(|cx| {
-                        if let Some(this) = Self::global(cx).as_ref() {
-                            this.update(cx, |this, cx| {
-                                this.oauth_token = oauth_token.clone();
-                                cx.notify();
-                            });
-                        }
-                    })?;
+                this.update(cx, |this, cx| {
+                    this.oauth_token = oauth_token.clone();
+                    cx.notify();
+                })?;

-                    if let Some(ref oauth_token) = oauth_token {
-                        let api_token = request_api_token(oauth_token, client.clone()).await?;
-                        cx.update(|cx| {
-                            if let Some(this) = Self::global(cx).as_ref() {
-                                this.update(cx, |this, cx| {
-                                    this.api_token = Some(api_token.clone());
-                                    cx.notify();
-                                });
-                            }
-                        })?;
-                        let models = get_models(api_token.api_key, client.clone()).await?;
-                        cx.update(|cx| {
-                            if let Some(this) = Self::global(cx).as_ref() {
-                                this.update(cx, |this, cx| {
-                                    this.models = Some(models);
-                                    cx.notify();
-                                });
-                            }
-                        })?;
-                    }
+                if oauth_token.is_some() {
+                    Self::update_models(&this, cx).await?;
                }
-                anyhow::Ok(())
            }
+            anyhow::Ok(())
        })
        .detach_and_log_err(cx);

-        Self {
-            oauth_token: None,
+        let this = Self {
+            oauth_token: std::env::var(COPILOT_OAUTH_ENV_VAR).ok(),
            api_token: None,
            models: None,
+            settings,
            client,
+        };
+        if this.oauth_token.is_some() {
+            cx.spawn(async move |this, mut cx| Self::update_models(&this, &mut cx).await)
+                .detach_and_log_err(cx);
        }
+
+        this
+    }
+
+    async fn update_models(this: &WeakEntity<Self>, cx: &mut AsyncApp) -> Result<()> {
+        let (oauth_token, client, auth_url) = this.read_with(cx, |this, _| {
+            (
+                this.oauth_token.clone(),
+                this.client.clone(),
+                this.settings.auth_url.clone(),
+            )
+        })?;
+        let api_token = request_api_token(
+            &oauth_token.ok_or_else(|| {
+                anyhow!("OAuth token is missing while updating Copilot Chat models")
+            })?,
+            auth_url,
+            client.clone(),
+        )
+        .await?;
+
+        let models_url = this.update(cx, |this, cx| {
+            this.api_token = Some(api_token.clone());
+            cx.notify();
+            this.settings.models_url.clone()
+        })?;
+        let models = get_models(models_url, api_token.api_key, client.clone()).await?;
+
+        this.update(cx, |this, cx| {
+            this.models = Some(models);
+            cx.notify();
+        })?;
+        anyhow::Ok(())
    }

    pub fn is_authenticated(&self) -> bool {
@@ -449,20 +471,23 @@ impl CopilotChat {
            .flatten()
            .context("Copilot chat is not enabled")?;

-        let (oauth_token, api_token, client) = this.read_with(&cx, |this, _| {
-            (
-                this.oauth_token.clone(),
-                this.api_token.clone(),
-                this.client.clone(),
-            )
-        })?;
+        let (oauth_token, api_token, client, api_url, auth_url) =
+            this.read_with(&cx, |this, _| {
+                (
+                    this.oauth_token.clone(),
+                    this.api_token.clone(),
+                    this.client.clone(),
+                    this.settings.api_url.clone(),
+                    this.settings.auth_url.clone(),
+                )
+            })?;

        let oauth_token = oauth_token.context("No OAuth token available")?;

        let token = match api_token {
            Some(api_token) if api_token.remaining_seconds() > 5 * 60 => api_token.clone(),
            _ => {
-                let token = request_api_token(&oauth_token, client.clone()).await?;
+                let token = request_api_token(&oauth_token, auth_url, client.clone()).await?;
                this.update(&mut cx, |this, cx| {
                    this.api_token = Some(token.clone());
                    cx.notify();
@@ -471,12 +496,28 @@ impl CopilotChat {
            }
        };

-        stream_completion(client.clone(), token.api_key, request).await
+        stream_completion(client.clone(), token.api_key, api_url, request).await
+    }
+
+    pub fn set_settings(&mut self, settings: CopilotChatSettings, cx: &mut Context<Self>) {
+        let same_settings = self.settings == settings;
+        self.settings = settings;
+        if !same_settings {
+            cx.spawn(async move |this, cx| {
+                Self::update_models(&this, cx).await?;
+                Ok::<_, anyhow::Error>(())
+            })
+            .detach();
+        }
    }
 }

-async fn get_models(api_token: String, client: Arc<dyn HttpClient>) -> Result<Vec<Model>> {
-    let all_models = request_models(api_token, client).await?;
+async fn get_models(
+    models_url: Arc<str>,
+    api_token: String,
+    client: Arc<dyn HttpClient>,
+) -> Result<Vec<Model>> {
+    let all_models = request_models(models_url, api_token, client).await?;

    let mut models: Vec<Model> = all_models
        .into_iter()
@@ -504,10 +545,14 @@ async fn get_models(api_token: String, client: Arc<dyn HttpClient>) -> Result<Ve
    Ok(models)
 }

-async fn request_models(api_token: String, client: Arc<dyn HttpClient>) -> Result<Vec<Model>> {
+async fn request_models(
+    models_url: Arc<str>,
+    api_token: String,
+    client: Arc<dyn HttpClient>,
+) -> Result<Vec<Model>> {
    let request_builder = HttpRequest::builder()
        .method(Method::GET)
-        .uri(COPILOT_CHAT_MODELS_URL)
+        .uri(models_url.as_ref())
        .header("Authorization", format!("Bearer {}", api_token))
        .header("Content-Type", "application/json")
        .header("Copilot-Integration-Id", "vscode-chat");
@@ -531,10 +576,14 @@ async fn request_models(api_token: String, client: Arc<dyn HttpClient>) -> Resul
    Ok(models)
 }

-async fn request_api_token(oauth_token: &str, client: Arc<dyn HttpClient>) -> Result<ApiToken> {
+async fn request_api_token(
+    oauth_token: &str,
+    auth_url: Arc<str>,
+    client: Arc<dyn HttpClient>,
+) -> Result<ApiToken> {
    let request_builder = HttpRequest::builder()
        .method(Method::GET)
-        .uri(COPILOT_CHAT_AUTH_URL)
+        .uri(auth_url.as_ref())
        .header("Authorization", format!("token {}", oauth_token))
        .header("Accept", "application/json");

@@ -579,6 +628,7 @@ fn extract_oauth_token(contents: String) -> Option<String> {
 async fn stream_completion(
    client: Arc<dyn HttpClient>,
    api_key: String,
+    completion_url: Arc<str>,
    request: Request,
 ) -> Result<BoxStream<'static, Result<ResponseEvent>>> {
    let is_vision_request = request.messages.last().map_or(false, |message| match message {
@@ -592,7 +642,7 @@ async fn stream_completion(

    let request_builder = HttpRequest::builder()
        .method(Method::POST)
-        .uri(COPILOT_CHAT_COMPLETION_URL)
+        .uri(completion_url.as_ref())
        .header(
            "Editor-Version",
            format!(
--- a/crates/dap/Cargo.toml
+++ b/crates/dap/Cargo.toml
@@ -51,6 +51,9 @@ telemetry.workspace = true
 util.workspace = true
 workspace-hack.workspace = true

+[target.'cfg(not(windows))'.dependencies]
+libc.workspace = true
+
 [dev-dependencies]
 async-pipe.workspace = true
 gpui = { workspace = true, features = ["test-support"] }
--- a/crates/dap/src/adapters.rs
+++ b/crates/dap/src/adapters.rs
@@ -181,7 +181,7 @@ impl DebugTaskDefinition {
 /// Created from a [DebugTaskDefinition], this struct describes how to spawn the debugger to create a previously-configured debug session.
 #[derive(Debug, Clone, PartialEq)]
 pub struct DebugAdapterBinary {
-    pub command: String,
+    pub command: Option<String>,
    pub arguments: Vec<String>,
    pub envs: HashMap<String, String>,
    pub cwd: Option<PathBuf>,
@@ -369,6 +369,10 @@ pub trait DebugAdapter: 'static + Send + Sync {
    }

    async fn dap_schema(&self) -> serde_json::Value;
+
+    fn label_for_child_session(&self, _args: &StartDebuggingRequestArguments) -> Option<String> {
+        None
+    }
 }

 #[cfg(any(test, feature = "test-support"))]
@@ -433,7 +437,7 @@ impl DebugAdapter for FakeAdapter {
        _: &mut AsyncApp,
    ) -> Result<DebugAdapterBinary> {
        Ok(DebugAdapterBinary {
-            command: "command".into(),
+            command: Some("command".into()),
            arguments: vec![],
            connection: None,
            envs: HashMap::default(),
--- a/crates/dap/src/client.rs
+++ b/crates/dap/src/client.rs
@@ -297,7 +297,7 @@ mod tests {
        let client = DebugAdapterClient::start(
            crate::client::SessionId(1),
            DebugAdapterBinary {
-                command: "command".into(),
+                command: Some("command".into()),
                arguments: Default::default(),
                envs: Default::default(),
                connection: None,
@@ -367,7 +367,7 @@ mod tests {
        let client = DebugAdapterClient::start(
            crate::client::SessionId(1),
            DebugAdapterBinary {
-                command: "command".into(),
+                command: Some("command".into()),
                arguments: Default::default(),
                envs: Default::default(),
                connection: None,
@@ -420,7 +420,7 @@ mod tests {
        let client = DebugAdapterClient::start(
            crate::client::SessionId(1),
            DebugAdapterBinary {
-                command: "command".into(),
+                command: Some("command".into()),
                arguments: Default::default(),
                envs: Default::default(),
                connection: None,
--- a/crates/dap/src/transport.rs
+++ b/crates/dap/src/transport.rs
@@ -1,4 +1,4 @@
-use anyhow::{Context as _, Result, bail};
+use anyhow::{Context as _, Result, anyhow, bail};
 use dap_types::{
    ErrorResponse,
    messages::{Message, Response},
@@ -12,7 +12,6 @@ use smol::{
    io::{AsyncBufReadExt as _, AsyncWriteExt, BufReader},
    lock::Mutex,
    net::{TcpListener, TcpStream},
-    process::Child,
 };
 use std::{
    collections::HashMap,
@@ -22,7 +21,7 @@ use std::{
    time::Duration,
 };
 use task::TcpArgumentsTemplate;
-use util::{ConnectionResult, ResultExt as _};
+use util::ConnectionResult;

 use crate::{adapters::DebugAdapterBinary, debugger_settings::DebuggerSettings};

@@ -86,10 +85,12 @@ impl Transport {
            TcpTransport::start(binary, cx)
                .await
                .map(|(transports, tcp)| (transports, Self::Tcp(tcp)))
+                .context("Tried to connect to a debug adapter via TCP transport layer")
        } else {
            StdioTransport::start(binary, cx)
                .await
                .map(|(transports, stdio)| (transports, Self::Stdio(stdio)))
+                .context("Tried to connect to a debug adapter via stdin/stdout transport layer")
        }
    }

@@ -102,7 +103,7 @@ impl Transport {
        }
    }

-    async fn kill(&self) -> Result<()> {
+    async fn kill(&self) {
        match self {
            Transport::Stdio(stdio_transport) => stdio_transport.kill().await,
            Transport::Tcp(tcp_transport) => tcp_transport.kill().await,
@@ -191,7 +192,7 @@ impl TransportDelegate {
                match Self::handle_output(
                    params.output,
                    client_tx,
-                    pending_requests,
+                    pending_requests.clone(),
                    output_log_handler,
                )
                .await
@@ -199,6 +200,12 @@ impl TransportDelegate {
                    Ok(()) => {}
                    Err(e) => log::error!("Error handling debugger output: {e}"),
                }
+                let mut pending_requests = pending_requests.lock().await;
+                pending_requests.drain().for_each(|(_, request)| {
+                    request
+                        .send(Err(anyhow!("debugger shutdown unexpectedly")))
+                        .ok();
+                });
            }));

            if let Some(stderr) = params.stderr.take() {
@@ -531,7 +538,7 @@ impl TransportDelegate {
        current_requests.clear();
        pending_requests.clear();

-        let _ = self.transport.kill().await.log_err();
+        self.transport.kill().await;

        drop(current_requests);
        drop(pending_requests);
@@ -562,7 +569,7 @@ pub struct TcpTransport {
    pub port: u16,
    pub host: Ipv4Addr,
    pub timeout: u64,
-    process: Mutex<Child>,
+    process: Option<Mutex<Child>>,
 }

 impl TcpTransport {
@@ -591,26 +598,23 @@ impl TcpTransport {
        let host = connection_args.host;
        let port = connection_args.port;

-        let mut command = util::command::new_std_command(&binary.command);
-        util::set_pre_exec_to_start_new_session(&mut command);
-        let mut command = smol::process::Command::from(command);
+        let mut process = if let Some(command) = &binary.command {
+            let mut command = util::command::new_std_command(&command);

-        if let Some(cwd) = &binary.cwd {
-            command.current_dir(cwd);
-        }
+            if let Some(cwd) = &binary.cwd {
+                command.current_dir(cwd);
+            }

-        command.args(&binary.arguments);
-        command.envs(&binary.envs);
+            command.args(&binary.arguments);
+            command.envs(&binary.envs);

-        command
-            .stdin(Stdio::null())
-            .stdout(Stdio::piped())
-            .stderr(Stdio::piped())
-            .kill_on_drop(true);
-
-        let mut process = command
-            .spawn()
-            .with_context(|| "failed to start debug adapter.")?;
+            Some(
+                Child::spawn(command, Stdio::null())
+                    .with_context(|| "failed to start debug adapter.")?,
+            )
+        } else {
+            None
+        };

        let address = SocketAddrV4::new(host, port);

@@ -628,15 +632,18 @@ impl TcpTransport {
                    match TcpStream::connect(address).await {
                        Ok(stream) => return Ok((process, stream.split())),
                        Err(_) => {
-                            if let Ok(Some(_)) = process.try_status() {
-                                let output = process.output().await?;
-                                let output = if output.stderr.is_empty() {
-                                    String::from_utf8_lossy(&output.stdout).to_string()
-                                } else {
-                                    String::from_utf8_lossy(&output.stderr).to_string()
-                                };
-                                anyhow::bail!("{output}\nerror: process exited before debugger attached.");
+                            if let Some(p) = &mut process {
+                                if let Ok(Some(_)) = p.try_status() {
+                                    let output = process.take().unwrap().into_inner().output().await?;
+                                    let output = if output.stderr.is_empty() {
+                                        String::from_utf8_lossy(&output.stdout).to_string()
+                                    } else {
+                                        String::from_utf8_lossy(&output.stderr).to_string()
+                                    };
+                                    anyhow::bail!("{output}\nerror: process exited before debugger attached.");
+                                }
                            }
+
                            cx.background_executor().timer(Duration::from_millis(100)).await;
                        }
                    }
@@ -649,13 +656,13 @@ impl TcpTransport {
            host,
            port
        );
-        let stdout = process.stdout.take();
-        let stderr = process.stderr.take();
+        let stdout = process.as_mut().and_then(|p| p.stdout.take());
+        let stderr = process.as_mut().and_then(|p| p.stderr.take());

        let this = Self {
            port,
            host,
-            process: Mutex::new(process),
+            process: process.map(Mutex::new),
            timeout,
        };

@@ -673,10 +680,19 @@ impl TcpTransport {
        true
    }

-    async fn kill(&self) -> Result<()> {
-        self.process.lock().await.kill()?;
+    async fn kill(&self) {
+        if let Some(process) = &self.process {
+            let mut process = process.lock().await;
+            Child::kill(&mut process);
+        }
+    }
+}

-        Ok(())
+impl Drop for TcpTransport {
+    fn drop(&mut self) {
+        if let Some(mut p) = self.process.take() {
+            p.get_mut().kill();
+        }
    }
 }

@@ -687,9 +703,12 @@ pub struct StdioTransport {
 impl StdioTransport {
    #[allow(dead_code, reason = "This is used in non test builds of Zed")]
    async fn start(binary: &DebugAdapterBinary, _: AsyncApp) -> Result<(TransportPipe, Self)> {
-        let mut command = util::command::new_std_command(&binary.command);
-        util::set_pre_exec_to_start_new_session(&mut command);
-        let mut command = smol::process::Command::from(command);
+        let Some(binary_command) = &binary.command else {
+            bail!(
+                "When using the `stdio` transport, the path to a debug adapter binary must be set by Zed."
+            );
+        };
+        let mut command = util::command::new_std_command(&binary_command);

        if let Some(cwd) = &binary.cwd {
            command.current_dir(cwd);
@@ -698,16 +717,10 @@ impl StdioTransport {
        command.args(&binary.arguments);
        command.envs(&binary.envs);

-        command
-            .stdin(Stdio::piped())
-            .stdout(Stdio::piped())
-            .stderr(Stdio::piped())
-            .kill_on_drop(true);
-
-        let mut process = command.spawn().with_context(|| {
+        let mut process = Child::spawn(command, Stdio::piped()).with_context(|| {
            format!(
                "failed to spawn command `{} {}`.",
-                binary.command,
+                binary_command,
                binary.arguments.join(" ")
            )
        })?;
@@ -722,7 +735,7 @@ impl StdioTransport {
        if stderr.is_none() {
            bail!(
                "Failed to connect to stderr for debug adapter command {}",
-                &binary.command
+                &binary_command
            );
        }

@@ -745,9 +758,15 @@ impl StdioTransport {
        false
    }

-    async fn kill(&self) -> Result<()> {
-        self.process.lock().await.kill()?;
-        Ok(())
+    async fn kill(&self) {
+        let mut process = self.process.lock().await;
+        Child::kill(&mut process);
+    }
+}
+
+impl Drop for StdioTransport {
+    fn drop(&mut self) {
+        self.process.get_mut().kill();
    }
 }

@@ -921,7 +940,66 @@ impl FakeTransport {
        false
    }

-    async fn kill(&self) -> Result<()> {
-        Ok(())
+    async fn kill(&self) {}
+}
+
+struct Child {
+    process: smol::process::Child,
+}
+
+impl std::ops::Deref for Child {
+    type Target = smol::process::Child;
+
+    fn deref(&self) -> &Self::Target {
+        &self.process
+    }
+}
+
+impl std::ops::DerefMut for Child {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.process
+    }
+}
+
+impl Child {
+    fn into_inner(self) -> smol::process::Child {
+        self.process
+    }
+
+    #[cfg(not(windows))]
+    fn spawn(mut command: std::process::Command, stdin: Stdio) -> Result<Self> {
+        util::set_pre_exec_to_start_new_session(&mut command);
+        let process = smol::process::Command::from(command)
+            .stdin(stdin)
+            .stdout(Stdio::piped())
+            .stderr(Stdio::piped())
+            .spawn()?;
+        Ok(Self { process })
+    }
+
+    #[cfg(windows)]
+    fn spawn(command: std::process::Command, stdin: Stdio) -> Result<Self> {
+        // TODO(windows): create a job object and add the child process handle to it,
+        // see https://learn.microsoft.com/en-us/windows/win32/procthread/job-objects
+        let process = smol::process::Command::from(command)
+            .stdin(stdin)
+            .stdout(Stdio::piped())
+            .stderr(Stdio::piped())
+            .spawn()?;
+        Ok(Self { process })
+    }
+
+    #[cfg(not(windows))]
+    fn kill(&mut self) {
+        let pid = self.process.id();
+        unsafe {
+            libc::killpg(pid as i32, libc::SIGKILL);
+        }
+    }
+
+    #[cfg(windows)]
+    fn kill(&mut self) {
+        // TODO(windows): terminate the job object in kill
+        let _ = self.process.kill();
    }
 }
--- a/crates/dap_adapters/Cargo.toml
+++ b/crates/dap_adapters/Cargo.toml
@@ -23,6 +23,7 @@ doctest = false
 [dependencies]
 anyhow.workspace = true
 async-trait.workspace = true
+collections.workspace = true
 dap.workspace = true
 futures.workspace = true
 gpui.workspace = true
--- a/crates/dap_adapters/src/codelldb.rs
+++ b/crates/dap_adapters/src/codelldb.rs
@@ -21,18 +21,21 @@ impl CodeLldbDebugAdapter {

    fn request_args(
        &self,
+        delegate: &Arc<dyn DapDelegate>,
        task_definition: &DebugTaskDefinition,
    ) -> Result<dap::StartDebuggingRequestArguments> {
        // CodeLLDB uses `name` for a terminal label.
        let mut configuration = task_definition.config.clone();

-        configuration
+        let obj = configuration
            .as_object_mut()
-            .context("CodeLLDB is not a valid json object")?
-            .insert(
-                "name".into(),
-                Value::String(String::from(task_definition.label.as_ref())),
-            );
+            .context("CodeLLDB is not a valid json object")?;
+
+        obj.entry("name")
+            .or_insert(Value::String(String::from(task_definition.label.as_ref())));
+
+        obj.entry("cwd")
+            .or_insert(delegate.worktree_root_path().to_string_lossy().into());

        let request = self.request_kind(&configuration)?;

@@ -359,13 +362,13 @@ impl DebugAdapter for CodeLldbDebugAdapter {
        };

        Ok(DebugAdapterBinary {
-            command: command.unwrap(),
+            command: Some(command.unwrap()),
            cwd: Some(delegate.worktree_root_path().to_path_buf()),
            arguments: vec![
                "--settings".into(),
                json!({"sourceLanguages": ["cpp", "rust"]}).to_string(),
            ],
-            request_args: self.request_args(&config)?,
+            request_args: self.request_args(delegate, &config)?,
            envs: HashMap::default(),
            connection: None,
        })
--- a/crates/dap_adapters/src/gdb.rs
+++ b/crates/dap_adapters/src/gdb.rs
@@ -177,18 +177,23 @@ impl DebugAdapter for GdbDebugAdapter {

        let gdb_path = user_setting_path.unwrap_or(gdb_path?);

-        let request_args = StartDebuggingRequestArguments {
-            request: self.request_kind(&config.config)?,
-            configuration: config.config.clone(),
-        };
+        let mut configuration = config.config.clone();
+        if let Some(configuration) = configuration.as_object_mut() {
+            configuration
+                .entry("cwd")
+                .or_insert_with(|| delegate.worktree_root_path().to_string_lossy().into());
+        }

        Ok(DebugAdapterBinary {
-            command: gdb_path,
+            command: Some(gdb_path),
            arguments: vec!["-i=dap".into()],
            envs: HashMap::default(),
            cwd: Some(delegate.worktree_root_path().to_path_buf()),
            connection: None,
-            request_args,
+            request_args: StartDebuggingRequestArguments {
+                request: self.request_kind(&config.config)?,
+                configuration,
+            },
        })
    }
 }
--- a/crates/dap_adapters/src/go.rs
+++ b/crates/dap_adapters/src/go.rs
@@ -462,14 +462,21 @@ impl DebugAdapter for GoDebugAdapter {
            ]
        };

+        let mut configuration = task_definition.config.clone();
+        if let Some(configuration) = configuration.as_object_mut() {
+            configuration
+                .entry("cwd")
+                .or_insert_with(|| delegate.worktree_root_path().to_string_lossy().into());
+        }
+
        Ok(DebugAdapterBinary {
-            command: minidelve_path.to_string_lossy().into_owned(),
+            command: Some(minidelve_path.to_string_lossy().into_owned()),
            arguments,
            cwd: Some(cwd),
            envs: HashMap::default(),
            connection: None,
            request_args: StartDebuggingRequestArguments {
-                configuration: task_definition.config.clone(),
+                configuration,
                request: self.request_kind(&task_definition.config)?,
            },
        })
--- a/crates/dap_adapters/src/javascript.rs
+++ b/crates/dap_adapters/src/javascript.rs
@@ -2,6 +2,7 @@ use adapters::latest_github_release;
 use anyhow::Context as _;
 use dap::{StartDebuggingRequestArguments, adapters::DebugTaskDefinition};
 use gpui::AsyncApp;
+use serde_json::Value;
 use std::{collections::HashMap, path::PathBuf, sync::OnceLock};
 use task::DebugRequest;
 use util::ResultExt;
@@ -68,13 +69,24 @@ impl JsDebugAdapter {
        let tcp_connection = task_definition.tcp_connection.clone().unwrap_or_default();
        let (host, port, timeout) = crate::configure_tcp_connection(tcp_connection).await?;

+        let mut configuration = task_definition.config.clone();
+        if let Some(configuration) = configuration.as_object_mut() {
+            configuration
+                .entry("cwd")
+                .or_insert(delegate.worktree_root_path().to_string_lossy().into());
+
+            configuration.entry("type").and_modify(normalize_task_type);
+        }
+
        Ok(DebugAdapterBinary {
-            command: delegate
-                .node_runtime()
-                .binary_path()
-                .await?
-                .to_string_lossy()
-                .into_owned(),
+            command: Some(
+                delegate
+                    .node_runtime()
+                    .binary_path()
+                    .await?
+                    .to_string_lossy()
+                    .into_owned(),
+            ),
            arguments: vec![
                adapter_path
                    .join(Self::ADAPTER_PATH)
@@ -91,7 +103,7 @@ impl JsDebugAdapter {
                timeout,
            }),
            request_args: StartDebuggingRequestArguments {
-                configuration: task_definition.config.clone(),
+                configuration,
                request: self.request_kind(&task_definition.config)?,
            },
        })
@@ -171,7 +183,7 @@ impl DebugAdapter for JsDebugAdapter {
                            "properties": {
                                "type": {
                                    "type": "string",
-                                    "enum": ["pwa-node", "node", "chrome", "pwa-chrome", "edge", "pwa-edge"],
+                                    "enum": ["pwa-node", "node", "chrome", "pwa-chrome", "msedge", "pwa-msedge"],
                                    "description": "The type of debug session",
                                    "default": "pwa-node"
                                },
@@ -431,4 +443,25 @@ impl DebugAdapter for JsDebugAdapter {
        self.get_installed_binary(delegate, &config, user_installed_path, cx)
            .await
    }
+
+    fn label_for_child_session(&self, args: &StartDebuggingRequestArguments) -> Option<String> {
+        let label = args.configuration.get("name")?.as_str()?;
+        Some(label.to_owned())
+    }
+}
+
+fn normalize_task_type(task_type: &mut Value) {
+    let Some(task_type_str) = task_type.as_str() else {
+        return;
+    };
+
+    let new_name = match task_type_str {
+        "node" | "pwa-node" => "pwa-node",
+        "chrome" | "pwa-chrome" => "pwa-chrome",
+        "edge" | "msedge" | "pwa-edge" | "pwa-msedge" => "pwa-msedge",
+        _ => task_type_str,
+    }
+    .to_owned();
+
+    *task_type = Value::String(new_name);
 }
--- a/Show More
+++ b/Show More
				`@@ -0,0 +1 @@`
				`<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-circle-help-icon lucide-circle-help"><circle cx="12" cy="12" r="10"/><path d="M9.09 9a3 3 0 0 1 5.83 1c0 2-3 3-3 3"/><path d="M12 17h.01"/></svg>`